Fixed creating new users in the database when awarding currency

Version upped to 3.0.8
Merge branch 'v3-dev' into 'v3'
2025-09-10 17:28:27 -04:00 · 2021-11-03 16:27:48 +01:00 · 2021-11-03 15:23:45 +01:00 · 2021-11-03 14:22:51 +00:00 · 2021-11-03 14:22:51 +00:00 · 2021-10-30 11:54:03 +00:00
176 changed files with 13126 additions and 7658 deletions
--- a/.dockerignore
+++ b/.dockerignore
@@ -9,6 +9,7 @@
 !src/NadekoBot.Generators/**
 # Use Ayu stuff
 !src/ayu/**
+!docker-entrypoint.sh

 # ignore bin and obj folders in projects
 src/**/bin/*
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -95,4 +95,31 @@ upload-windows-updater-release:
    - sed -i "s/_VERSION_/$CI_COMMIT_TAG/g" releases-v3.json
    - aws --version
    - aws --endpoint-url $AWS_SERVICE_URL s3api put-object --bucket "$AWS_BUCKET_NAME" --key "dl/bot/$INSTALLER_FILE_NAME" --acl public-read --body "$INSTALLER_OUTPUT_DIR/$INSTALLER_FILE_NAME"
-    - aws --endpoint-url $AWS_SERVICE_URL s3api put-object --bucket "$AWS_BUCKET_NAME" --key "dl/bot/releases-v3.json" --acl public-read --body "releases-v3.json"
+    - aws --endpoint-url $AWS_SERVICE_URL s3api put-object --bucket "$AWS_BUCKET_NAME" --key "dl/bot/releases-v3.json" --acl public-read --body "releases-v3.json"
+
+docker-build:
+  # Use the official docker image.
+  image: docker:latest
+  stage: build
+  services:
+    - docker:dind
+  before_script:
+    - docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" $CI_REGISTRY
+  # Default branch leaves tag empty (= latest tag)
+  # All other branches are tagged with the escaped branch name (commit ref slug)
+  script:
+    - |
+      if [[ "$CI_COMMIT_BRANCH" == "$CI_DEFAULT_BRANCH" ]]; then
+        tag=""
+        echo "Running on default branch '$CI_DEFAULT_BRANCH': tag = 'latest'"
+      else
+        tag=":$CI_COMMIT_REF_SLUG"
+        echo "Running on branch '$CI_COMMIT_BRANCH': tag = $tag"
+      fi
+    - docker build --pull -t "$CI_REGISTRY_IMAGE${tag}" .
+    - docker push "$CI_REGISTRY_IMAGE${tag}"
+  # Run this job in a branch where a Dockerfile exists
+  rules:
+    - if: $CI_COMMIT_BRANCH
+      exists:
+        - Dockerfile
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,7 +4,60 @@ Experimental changelog. Mostly based on [keepachangelog](https://keepachangelog.

 ## Unreleased

+## [3.0.7]

+### Added
+- `.streamsclear` re-added. It will remove all followed streams on the server.
+- `.gifts` now have 3 new ✂️ Haircut 🧻 ToiletPaper and 🥀 WiltedRose which **reduce** waifu's value
+  - They are called negative gifts
+  - They show up at the end of the `.gifts` page and are marked with a broken heart
+  - They have a separate multiplier (`waifu.multi.negative_gift_effect` default 0.5, changeable via `.config gambling` or `data/gambling.yml`)
+  - When gifted, the waifu's price will be reduced by the `price * multiplier` 
+  - Negative gifts don't show up in `.waifuinfo` nor is the record of them kept in the database
+
+### Fixed 
+- Fixed `%users%` and `%shard.usercount%` placeholders not showing correct values
+
+## [3.0.6] - 27.09.2021
+
+### Added
+
+- .logignore now supports ignoring users and channels. Use without parameters to see the ignore list
+
+### Changed
+
+- Hangman rewrite
+  - Hangman categories are now held in separate .yml files in data/hangman/XYZ.yml where XYZ is the category name
+
+### Fixed
+
+- Fixed an exception which caused repeater queue to break
+- Fixed url field not working in embeds
+
+## [3.0.5] - 20.09.2021
+
+### Fixed
+
+- Fixed images not automatically reloading on startup if the keys don't exist
+- Fixed `.logserver` - it should no longer throw an exception if you had no logsettings previously
+
+## [3.0.4] - 16.09.2021
+
+### Added
+
+- Fully translated to Brazilian Portuguese 🎉
+- Added `%server.boosters%` and `%server.boost_level%` placeholders
+- Added `DmHelpTextKeywords` to `data/bot.yml`
+  - Bot now sends dm help text ONLY if the message contains one of the keywords specified
+  - If no keywords are specified, bot will reply to every DM (like before)
+
+### Fixed
+
+- Possible fix for `.repeat` bug
+  - Slight adjustment for repeater logic
+  - Timer should no longer increase on some repeaters
+  - Repeaters should no longer have periods when they're missing from the list  
+- Fixed several commands which used error color for success confirmation messages

 ## [3.0.3] - 15.09.2021

--- a/36
+++ b/36
@@ -1,4 +1,4 @@
-FROM mcr.microsoft.com/dotnet/sdk:5.0 AS build
+FROM mcr.microsoft.com/dotnet/sdk:5.0-buster-slim AS build
 WORKDIR /source

 COPY src/NadekoBot/*.csproj src/NadekoBot/
@@ -9,14 +9,34 @@ RUN dotnet restore src/NadekoBot/

 COPY . .
 WORKDIR /source/src/NadekoBot
-RUN dotnet --version
-RUN dotnet publish -c Release -o /app --no-restore
+RUN set -xe; \
+    dotnet --version; \
+    dotnet publish -c Release -o /app --no-restore; \
+    mv /app/data /app/data_init; \
+    rm -Rf libopus* libsodium* opus.* runtimes/win* runtimes/osx* runtimes/linux-arm* runtimes/linux-mips*; \
+    find /app -type f -exec chmod -x {} \; ;\
+    chmod +x /app/NadekoBot

 # final stage/image
-FROM mcr.microsoft.com/dotnet/runtime:5.0
+FROM mcr.microsoft.com/dotnet/runtime:5.0-buster-slim
+WORKDIR /app
+
+RUN set -xe; \
+    useradd -m nadeko; \
+    apt-get update; \
+    apt-get install -y libopus0 libsodium23 libsqlite3-0 curl ffmpeg python3 python3-pip sudo; \
+    update-alternatives --install /usr/bin/python python /usr/bin/python3.7 1; \
+    echo 'Defaults>nadeko env_keep+="ASPNETCORE_* DOTNET_* NadekoBot_* shard_id total_shards TZ"' > /etc/sudoers.d/nadeko; \
+    pip3 install --upgrade youtube-dl; \
+    apt-get remove -y python3-pip; \
+    chmod +x /usr/local/bin/youtube-dl
+
+COPY --from=build /app ./
+COPY docker-entrypoint.sh /usr/local/sbin
+
 ENV shard_id=0
 ENV total_shards=1
-WORKDIR /app
-COPY --from=build /app ./
-VOLUME [ "app/data", "app/creds.yml", "app/creds_example.yml" ]
-ENTRYPOINT dotnet NadekoBot.dll "$shard_id" "$total_shards"
+
+VOLUME [ "app/data" ]
+ENTRYPOINT [ "/usr/local/sbin/docker-entrypoint.sh" ]
+CMD dotnet NadekoBot.dll "$shard_id" "$total_shards"
--- a/NadekoBot.sln
+++ b/NadekoBot.sln
@@ -25,6 +25,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NadekoBot.Coordinator", "sr
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NadekoBot.Generators", "src\NadekoBot.Generators\NadekoBot.Generators.csproj", "{3BC3BDF8-1A0B-45EB-AB2B-C0891D4D37B8}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NadekoBot.VotesApi", "src\NadekoBot.VotesApi\NadekoBot.VotesApi.csproj", "{3BC82CFE-BEE7-451F-986B-17EDD1570C4F}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -62,6 +64,12 @@ Global
 		{3BC3BDF8-1A0B-45EB-AB2B-C0891D4D37B8}.GlobalNadeko|Any CPU.Build.0 = Debug|Any CPU
 		{3BC3BDF8-1A0B-45EB-AB2B-C0891D4D37B8}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{3BC3BDF8-1A0B-45EB-AB2B-C0891D4D37B8}.Release|Any CPU.Build.0 = Release|Any CPU
+		{3BC82CFE-BEE7-451F-986B-17EDD1570C4F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3BC82CFE-BEE7-451F-986B-17EDD1570C4F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3BC82CFE-BEE7-451F-986B-17EDD1570C4F}.GlobalNadeko|Any CPU.ActiveCfg = Debug|Any CPU
+		{3BC82CFE-BEE7-451F-986B-17EDD1570C4F}.GlobalNadeko|Any CPU.Build.0 = Debug|Any CPU
+		{3BC82CFE-BEE7-451F-986B-17EDD1570C4F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{3BC82CFE-BEE7-451F-986B-17EDD1570C4F}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -73,6 +81,7 @@ Global
 		{DB448DD4-C97F-40E9-8BD3-F605FF1FF833} = {04929013-5BAB-42B0-B9B2-8F2BB8F16AF2}
 		{AE9B7F8C-81D7-4401-83A3-643B38258374} = {04929013-5BAB-42B0-B9B2-8F2BB8F16AF2}
 		{3BC3BDF8-1A0B-45EB-AB2B-C0891D4D37B8} = {04929013-5BAB-42B0-B9B2-8F2BB8F16AF2}
+		{3BC82CFE-BEE7-451F-986B-17EDD1570C4F} = {04929013-5BAB-42B0-B9B2-8F2BB8F16AF2}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {5F3F555C-855F-4BE8-B526-D062D3E8ACA4}
--- a/docker-entrypoint.sh
+++ b/docker-entrypoint.sh
@@ -0,0 +1,20 @@
+#!/bin/sh
+set -e;
+
+data_init=/app/data_init
+data=/app/data
+
+# populate /app/data if empty
+for i in $(ls $data_init)
+do
+    if [ ! -e "$data/$i" ]; then
+        [ -f "$data_init/$i" ] && cp "$data_init/$i" "$data/$i"
+        [ -d "$data_init/$i" ] && cp -r "$data_init/$i" "$data/$i"
+    fi
+done
+
+# fix folder permissions
+chown -R nadeko:nadeko "$data"
+
+# drop to regular user and launch command
+exec sudo -u nadeko "$@"
--- a/docs/guides/docker-guide.md
+++ b/docs/guides/docker-guide.md
@@ -1,3 +1,35 @@
 # Setting up NadekoBot with Docker

-Soon:tm:
+# DO NOT USE YET - WORK IN PROGRESS
+
+Upgrade from 2.x to v3 does not work because the file is mount readonly
+
+### Docker Compose 
+```yml
+version: "3.7"
+services:
+  nadeko:
+    image: registry.gitlab.com/veovis/nadekobot:v3-docker
+    depends_on:
+      - redis
+    environment:
+      TZ: Europe/Paris
+      #NadekoBot_RedisOptions: redis,name=nadeko
+      #NadekoBot_ShardRunCommand: dotnet
+      #NadekoBot_ShardRunArguments: /app/NadekoBot.dll {0} {1}
+    volumes:
+      - /srv/nadeko/conf/creds.yml:/app/creds.yml:ro
+      - /srv/nadeko/data:/app/data
+
+  redis:
+    image: redis:4-alpine
+    sysctls:
+      - net.core.somaxconn=511
+    command: redis-server --maxmemory 32M --maxmemory-policy volatile-lru
+    volumes:
+      - /srv/nadeko/redis-data:/data
+```
+### Updating
+- `cd /srv/nadeko`
+- `docker-compose pull`
+- `docker-compose up -d`
--- a/docs/guides/linux-guide.md
+++ b/docs/guides/linux-guide.md
@@ -16,12 +16,12 @@ Open Terminal (if you're on an installation with a window manager) and navigate
 4. Exit the installer in order to set up your `creds.yml` 
 5. Copy the creds.yml template `cp nadekobot/output/creds_example.yml nadekobot/output/creds.yml` 
 6. Open `nadekobot/output/creds.yml` with your favorite text editor. We will use nano here
-   - `nano nadekobot/output/creds.yml`
+    - `nano nadekobot/output/creds.yml`
 7. [Enter your bot's token](../../creds-guide)
-   - After you're done, you can close nano (and save the file) by inputting, in order 
-      - `CTRL` + `X`
-      - `Y`
-      - `Enter`
+    - After you're done, you can close nano (and save the file) by inputting, in order 
+       - `CTRL` + `X`
+       - `Y`
+       - `Enter`
 8. Run the bot (type `3` and press enter)

 ##### Update Instructions
@@ -37,51 +37,51 @@ Open Terminal (if you're on an installation with a window manager) and navigate
 ##### Installation Instructions

 1. Download the latest release from <https://gitlab.com/Kwoth/nadekobot/-/releases>
-   - Look for the file called "X.XX.X-linux-x64-build.tar" (where X.XX.X is a series of numbers) and download it
+    - Look for the file called "X.XX.X-linux-x64-build.tar" (where X.XX.X is a series of numbers) and download it
 2. Untar it 
-   - ⚠ Make sure that you change X.XX.X to the same series of numbers as in step 1!
-   - `tar xf X.XX.X-linux-x64-build.tar`
+    - ⚠ Make sure that you change X.XX.X to the same series of numbers as in step 1!
+    - `tar xf X.XX.X-linux-x64-build.tar`
 3. Rename the `nadekobot-linux-x64` to `nadekobot` 
-   - `mv nadekobot-linux-x64 nadekobot`
+    - `mv nadekobot-linux-x64 nadekobot`
 4. Move into nadekobot directory and make NadekoBot executable
-   - `cd nadekobot && chmod +x NadekoBot`
+    - `cd nadekobot && chmod +x NadekoBot`
 5. Copy the creds.yml template 
-   - `cp creds_example.yml creds.yml` 
+    - `cp creds_example.yml creds.yml` 
 6. Open `creds.yml` with your favorite text editor. We will use nano here
-   - `nano nadekobot/output/creds.yml`
+    - `nano nadekobot/output/creds.yml`
 8. [Enter your bot's token](#creds-guide)
-   - After you're done, you can close nano (and save the file) by inputting, in order 
-      - `CTRL` + `X`
-      - `Y`
-      - `Enter`
+    - After you're done, you can close nano (and save the file) by inputting, in order 
+       - `CTRL` + `X`
+       - `Y`
+       - `Enter`
 9. Run the bot
-   - `./NadekoBot`
+    - `./NadekoBot`

 ##### Update Instructions

 1. Stop the bot
 2. Download the latest release from <https://gitlab.com/Kwoth/nadekobot/-/releases>
-   - Look for the file called "X.XX.X-linux-x64-build.tar" (where X.XX.X is a series of numbers) and download it
+    - Look for the file called "x.x.x-linux-x64-build.tar" (where `X.X.X` is a version, for example 3.0.4) and download it
 3. Untar it 
-   - ⚠ Make sure that you change X.XX.X to the same series of numbers as in step 2!
-   - `tar xf 2.99.8-linux-x64-build.tar`
+    - ⚠ Make sure that you change `X.X.X` to the same series of numbers as in step 2!
+    - `tar xf x.x.x-linux-x64-build.tar`
 4. Rename the old nadekobot directory to nadekobot-old (remove your old backup first if you have one, or back it up under a different name)
-   - `rm -rf nadekobot-old 2>/dev/null`
-   - `mv nadekobot nadekobot-old`
+    - `rm -rf nadekobot-old 2>/dev/null`
+    - `mv nadekobot nadekobot-old`
 5. Rename the new nadekobot directory to nadekobot
-   - `mv nadekobot-linux-x64 nadekobot`
+    - `mv nadekobot-linux-x64 nadekobot`
 6. Remove old strings and aliases to avoid overwriting the updated versions of those files  
-   - ⚠ If you've modified said files, back them up instead
-   - `rm nadekobot-old/data/aliases.yml`
-   - `rm -r nadekobot-old/data/strings`
+    - ⚠ If you've modified said files, back them up instead
+    - `rm nadekobot-old/data/aliases.yml`
+    - `rm -r nadekobot-old/data/strings`
 7. Copy old data
-   - `cp -RT nadekobot-old/data/ nadekobot/data/`
+    - `cp -RT nadekobot-old/data/ nadekobot/data`
 8. Copy creds.yml
-   - `cp nadekobot-old/creds.yml nadekobot/`
+    - `cp nadekobot-old/creds.yml nadekobot/`
 9. Move into nadekobot directory and make the NadekoBot executable
-   - `cd nadekobot && chmod +x NadekoBot`
+    - `cd nadekobot && chmod +x NadekoBot`
 10. Run the bot 
-   - `./NadekoBot`
+    - `./NadekoBot`

 🎉 Enjoy

@@ -95,7 +95,152 @@ mv nadekobot nadekobot-old && \
 mv nadekobot-linux-x64 nadekobot && \
 rm nadekobot-old/data/aliases.yml && \
 rm -r nadekobot-old/data/strings && \
-cp -RT nadekobot-old/data/ nadekobot/data/ && \
+cp -RT nadekobot-old/data/ nadekobot/data && \
 cp nadekobot-old/creds.yml nadekobot/ && \
 cd nadekobot && chmod +x NadekoBot
 ```
+
+## Running Nadeko
+
+While there are two run modes built into the installer, these options only run Nadeko within the current session. Below are 3 methods of running Nadeko as a background process.
+
+### Tmux (Preferred Method)
+
+Using `tmux` is the simplest method, and is therefore recommended for most users.
+
+1. Start a tmux session:
+    - `tmux`
+2. Navigate to the project's root directory
+    - Project root directory location example: `/home/user/nadekobot/`
+3. Enter the `output` directory:
+    - `cd output`
+4. Run the bot using:
+    - `dotnet NadekoBot.dll`
+5. Detatch the tmux session:
+    - Press `Ctrl` + `B`
+    - Then press `D`
+
+Nadeko should now be running in the background of your system. To re-open the tmux session to either update, restart, or whatever, execute `tmux a`.
+
+### Systemd
+
+Compared to using tmux, this method requires a little bit more work to set up, but has the benefit of allowing Nadeko to automatically start back up after a system reboot or the execution of the `.die` command.
+
+1. Navigate to the project's root directory
+    - Project root directory location example: `/home/user/nadekobot/`
+2. Use the following command to create a service that will be used to start Nadeko:
+
+    ```bash
+    echo "[Unit]
+    Description=NadekoBot service
+    After=network.target
+    StartLimitIntervalSec=60
+    StartLimitBurst=2
+    
+    [Service]
+    Type=simple
+    User=$USER
+    WorkingDirectory=$PWD/output
+    # If you want Nadeko to be compiled prior to every startup, uncomment the lines
+    # below. Note  that it's not neccessary unless you are personally modifying the
+    # source code.
+    #ExecStartPre=/usr/bin/dotnet build ../src/NadekoBot/NadekoBot.csproj -c Release -o output/
+    ExecStart=/usr/bin/dotnet NadekoBot.dll
+    Restart=on-failure
+    RestartSec=5
+    StandardOutput=syslog
+    StandardError=syslog
+    SyslogIdentifier=NadekoBot
+    
+    [Install]
+    WantedBy=multi-user.target" | sudo tee /etc/systemd/system/nadeko.service
+    ```
+    
+3. Make the new service available:
+    - `sudo systemctl daemon-reload`
+4. Start Nadeko:
+    - `sudo systemctl start nadeko.service && sudo systemctl enable nadeko.service`
+    
+
+### Systemd + Script
+
+This method is similar to the one above, but requires one extra step, with the added benefit of better error logging and control over what happens before and after the startup of Nadeko.
+
+1. Locate the project and move to its parent directory
+    - Project location example: `/home/user/nadekobot/`
+    - Parent directory example: `/home/user/`
+2. Use the following command to create a service that will be used to execute `NadekoRun.sh`:
+
+    ```bash
+    echo "[Unit]
+    Description=NadekoBot service
+    After=network.target
+    StartLimitIntervalSec=60
+    StartLimitBurst=2
+    
+    [Service]
+    Type=simple
+    User=$USER
+    WorkingDirectory=$_WORKING_DIR
+    ExecStart=/bin/bash NadekoRun.sh
+    Restart=on-failure
+    RestartSec=5
+    StandardOutput=syslog
+    StandardError=syslog
+    SyslogIdentifier=NadekoBot
+    
+    [Install]
+    WantedBy=multi-user.target" | sudo tee /etc/systemd/system/nadeko.service
+    ```
+    
+3. Make the new service available:
+    - `sudo systemctl daemon-reload`
+4. Use the following command to create a script that will be used to start Nadeko:
+    
+    ```bash
+    {
+    echo '#!/bin/bash'
+    echo ""
+    echo "echo \"Running NadekoBot in the background with auto restart\"
+    youtube-dl -U
+    
+    # If you want Nadeko to be compiled prior to every startup, uncomment the lines
+    # below. Note  that it's not necessary unless you are personally modifying the
+    # source code.
+    #echo \"Compiling NadekoBot...\"
+    #cd \"$PWD\"/nadekobot
+    #dotnet build src/NadekoBot/NadekoBot.csproj -c Release -o output/
+
+    echo \"Starting NadekoBot...\"
+    
+    while true; do
+        if [[ -d $PWD/nadekobot/output ]]; then
+            cd $PWD/nadekobot/output || {
+                echo \"Failed to change working directory to $PWD/nadekobot/output\" >&2
+                echo \"Ensure that the working directory inside of '/etc/systemd/system/nadeko.service' is correct\"
+                echo \"Exiting...\"
+                exit 1
+            }
+        else
+            echo \"$PWD/nadekobot/output doesn't exist\"
+            exit 1
+        fi
+        
+        dotnet NadekoBot.dll || {
+            echo \"An error occurred when trying to start NadekBot\"
+            echo \"Exiting...\"
+            exit 1
+        }
+        
+        echo \"Waiting for 5 seconds...\"
+        sleep 5
+        youtube-dl -U
+        echo \"Restarting NadekoBot...\"
+    done
+    
+    echo \"Stopping NadekoBot...\""
+    } > NadekoRun.sh
+    ```
+    
+5. Start Nadeko:
+    - `sudo systemctl start nadeko.service && sudo systemctl enable nadeko.service`
--- a/docs/guides/windows-guide.md
+++ b/docs/guides/windows-guide.md
@@ -32,12 +32,13 @@

 - Download and run the [NadekoBot v3 Updater][Updater].
 - Click on the + at the top left to create a new bot.
- ![NadekoBot Updater](https://i.imgur.com/KZV49uf.png "NadekoBot Updater")
+ ![NadekoBot Updater](https://i.imgur.com/FmR7F7o.png "NadekoBot Updater")
 - Give your bot a name and then click **`Go to setup`** at the lower right.
- ![Create a new bot](https://i.imgur.com/Xnp7iQL.png "Create a new bot")
+ ![Create a new bot](https://i.imgur.com/JxtRk9e.png "Create a new bot")
 - Click on **`DOWNLOAD`** at the lower right
- ![Bot Setup](https://i.imgur.com/6RMXNqw.png "Bot Setup")
+ ![Bot Setup](https://i.imgur.com/HqAl36p.png "Bot Setup")
 - Click on **`Install`** next to **`Redis`**.
+- **Note: If Redis fails to install, install Redis manually here: [Redis Installer](https://github.com/MicrosoftArchive/redis/releases/tag/win-3.0.504) Download and run the **`.msi`** file.
 - If you will use the music module, click on **`Install`** next to **`FFMPEG`** and **`Youtube-DL`**.
 - If any dependencies fail to install, you can temporarily disable your Windows Defender/AV until you install them. If you don't want to, then read [the last section of this guide](#Manual-Prerequisite-Installation).
 - When installation is finished, click on **`CREDS`** to the left of **`RUN`** at the lower right.
@@ -80,6 +81,7 @@ You can still install them manually:
 Open PowerShell (press windows button on your keyboard and type powershell, it should show up; alternatively, right click the start menu and select Windows PowerShell), and navigate to the location where you want to install the bot (for example `cd ~/Desktop/`)  

 1. `git clone https://gitlab.com/kwoth/nadekobot -b v3 --depth 1`
+2. `cd nadekobot`
 3. `dotnet publish -c Release -o output/ src/NadekoBot/`
 4. `cd output && cp creds_example.yml creds.yml`
 5. Open `creds.yml` with your favorite text editor (Please don't use Notepad or WordPad. You can use Notepad++, VSCode, Atom, Sublime, or something similar)
@@ -91,16 +93,30 @@ Open PowerShell (press windows button on your keyboard and type powershell, it s

 Open PowerShell as described above and run the following commands:

-1. Navigate to your bot's folder, for example `cd ~/Desktop/nadekobot/src/NadekoBot`
-2. Pull the latest updates (this will fail if you have custom code changes).
-   - If you don't have custom code changes, just run `git pull`
-   - If you do have custom code changes, You have 3 options
-      - Undo all changes with `git checkout -- * && git pull`
-      - Stash changes and try to re-apply them `git stash && git pull && git stash apply`
-      - Commit your changes and resolve merge conflicts `git add . && git commit -m "My commit message" && git pull`
-3. Re-run the bot `dotnet run -c Release`
+1. Stop the bot
+  - ⚠️ Make sure you don't have your database, credentials or any other nadekobot folder open in some application, this might prevent some of the steps from executing succesfully
+2. Navigate to your bot's folder, example:
+    - `cd ~/Desktop/nadekobot`
+3. Pull the new version
+    - `git pull`
+    - ⚠️ If this fails, you may want to stash or remove your code changes if you don't know how to resolve merge conflicts
+4. **Backup** old output in case your data is overwritten
+    - `cp -r -fo output/ output-old`
+5. Build the bot again
+    - `dotnet publish -c Release -o output/ src/NadekoBot/`
+6. Remove old strings and aliases to avoid overwriting the updated versions of those files  
+    - ⚠ If you've modified said files, back them up instead
+    - `rm output-old/data/aliases.yml`
+    - `rm -r output-old/data/strings`
+7. Copy old data
+    - `cp -Recurse .\output-old\data\ .\output\ -Force`
+8. Copy creds.yml
+    - `cp output-old/creds.yml output/`
+9. Run the bot 
+    - `cd output`
+    - `dotnet NadekoBot.dll`

-⚠ You're expected to understand that your database will be in `bin/Release/<framework>/data/`, and if `<framework>` gets changed in the future, you will have to move your database manually.
+🎉 Enjoy

 #### Music prerequisites  
 In order to use music commands, you need ffmpeg and youtube-dl installed.
--- a/src/NadekoBot.VotesApi/.dockerignore
+++ b/src/NadekoBot.VotesApi/.dockerignore
@@ -0,0 +1,25 @@
+**/.dockerignore
+**/.env
+**/.git
+**/.gitignore
+**/.project
+**/.settings
+**/.toolstarget
+**/.vs
+**/.vscode
+**/.idea
+**/*.*proj.user
+**/*.dbmdl
+**/*.jfm
+**/azds.yaml
+**/bin
+**/charts
+**/docker-compose*
+**/Dockerfile*
+**/node_modules
+**/npm-debug.log
+**/obj
+**/secrets.dev.yaml
+**/values.dev.yaml
+LICENSE
+README.md
--- a/src/NadekoBot.VotesApi/.gitignore
+++ b/src/NadekoBot.VotesApi/.gitignore
@@ -0,0 +1 @@
+store/
--- a/src/NadekoBot.VotesApi/Common/AuthHandler.cs
+++ b/src/NadekoBot.VotesApi/Common/AuthHandler.cs
@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.Security.Claims;
+using System.Text.Encodings.Web;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using NadekoBot.VotesApi.Controllers;
+
+namespace NadekoBot.VotesApi
+{
+    public class AuthHandler : AuthenticationHandler<AuthenticationSchemeOptions>
+    {
+        public const string SchemeName = "AUTHORIZATION_SCHEME";
+        public const string DiscordsClaim = "DISCORDS_CLAIM";
+        public const string TopggClaim = "TOPGG_CLAIM";
+
+        private readonly IConfiguration _conf;
+
+        public AuthHandler(IOptionsMonitor<AuthenticationSchemeOptions> options,
+            ILoggerFactory logger,
+            UrlEncoder encoder,
+            ISystemClock clock,
+            IConfiguration conf)
+            : base(options, logger, encoder, clock)
+        {
+            _conf = conf;
+        }
+
+        protected override Task<AuthenticateResult> HandleAuthenticateAsync()
+        {
+            var claims = new List<Claim>();
+
+            if (_conf[ConfKeys.DISCORDS_KEY].Trim() == Request.Headers["Authorization"].ToString().Trim())
+                claims.Add(new(DiscordsClaim, "true"));
+
+            if (_conf[ConfKeys.TOPGG_KEY] == Request.Headers["Authorization"].ToString().Trim())
+                claims.Add(new Claim(TopggClaim, "true"));
+
+            return Task.FromResult(AuthenticateResult.Success(new(new(new ClaimsIdentity(claims)), SchemeName)));
+        }
+    }
+}
--- a/src/NadekoBot.VotesApi/Common/ConfKeys.cs
+++ b/src/NadekoBot.VotesApi/Common/ConfKeys.cs
@@ -0,0 +1,8 @@
+namespace NadekoBot.VotesApi
+{
+    public static class ConfKeys
+    {
+        public const string DISCORDS_KEY = "DiscordsKey";
+        public const string TOPGG_KEY = "TopGGKey";
+    }
+}
--- a/src/NadekoBot.VotesApi/Common/DiscordsVoteWebhookModel.cs
+++ b/src/NadekoBot.VotesApi/Common/DiscordsVoteWebhookModel.cs
@@ -0,0 +1,26 @@
+namespace NadekoBot.VotesApi
+{
+    public class DiscordsVoteWebhookModel
+    {
+        /// <summary>
+        /// The ID of the user who voted
+        /// </summary>
+        public string User { get; set; }
+
+        /// <summary>
+        /// The ID of the bot which recieved the vote
+        /// </summary>
+        public string Bot { get; set; }
+
+        /// <summary>
+        /// Contains totalVotes, votesMonth, votes24, hasVoted - a list of IDs of users who have voted this month, and
+        /// Voted24 - a list of IDs of users who have voted today
+        /// </summary>
+        public string Votes { get; set; }
+
+        /// <summary>
+        /// The type of event, whether it is a vote event or test event
+        /// </summary>
+        public string Type { get; set; }
+    }
+}
--- a/src/NadekoBot.VotesApi/Common/Policies.cs
+++ b/src/NadekoBot.VotesApi/Common/Policies.cs
@@ -0,0 +1,8 @@
+namespace NadekoBot.VotesApi
+{
+    public static class Policies
+    {
+        public const string DiscordsAuth = "DiscordsAuth";
+        public const string TopggAuth = "TopggAuth";
+    }
+}
--- a/src/NadekoBot.VotesApi/Common/TopggVoteWebhookModel.cs
+++ b/src/NadekoBot.VotesApi/Common/TopggVoteWebhookModel.cs
@@ -0,0 +1,30 @@
+namespace NadekoBot.VotesApi
+{
+    public class TopggVoteWebhookModel
+    {
+        /// <summary>
+        /// Discord ID of the bot that received a vote.
+        /// </summary>
+        public string Bot { get; set; }
+        
+        /// <summary>
+        /// Discord ID of the user who voted.
+        /// </summary>
+        public string User { get; set; }
+        
+        /// <summary>
+        /// The type of the vote (should always be "upvote" except when using the test button it's "test").
+        /// </summary>
+        public string Type { get; set; }
+        
+        /// <summary>
+        /// Whether the weekend multiplier is in effect, meaning users votes count as two.
+        /// </summary>
+        public bool Weekend { get; set; }
+        
+        /// <summary>
+        /// Query string params found on the /bot/:ID/vote page. Example: ?a=1&b=2.
+        /// </summary>
+        public string Query { get; set; }
+    }
+}
--- a/src/NadekoBot.VotesApi/Controllers/DiscordsController.cs
+++ b/src/NadekoBot.VotesApi/Controllers/DiscordsController.cs
@@ -0,0 +1,33 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using NadekoBot.VotesApi.Services;
+
+namespace NadekoBot.VotesApi.Controllers
+{
+    [ApiController]
+    [Route("[controller]")]
+    public class DiscordsController : ControllerBase
+    {
+        private readonly ILogger<TopGgController> _logger;
+        private readonly IVotesCache _cache;
+
+        public DiscordsController(ILogger<TopGgController> logger, IVotesCache cache)
+        {
+            _logger = logger;
+            _cache = cache;
+        }
+
+        [HttpGet("new")]
+        [Authorize(Policy = Policies.DiscordsAuth)]
+        public async Task<IEnumerable<Vote>> New()
+        {
+            var votes = await _cache.GetNewDiscordsVotesAsync();
+            if(votes.Count > 0)
+                _logger.LogInformation("Sending {NewDiscordsVotes} new discords votes.", votes.Count);
+            return votes;
+        }
+    }
+}
--- a/src/NadekoBot.VotesApi/Controllers/TopGgController.cs
+++ b/src/NadekoBot.VotesApi/Controllers/TopGgController.cs
@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using NadekoBot.VotesApi.Services;
+
+namespace NadekoBot.VotesApi.Controllers
+{
+    [ApiController]
+    [Route("[controller]")]
+    public class TopGgController : ControllerBase
+    {
+        private readonly ILogger<TopGgController> _logger;
+        private readonly IVotesCache _cache;
+
+        public TopGgController(ILogger<TopGgController> logger, IVotesCache cache)
+        {
+            _logger = logger;
+            _cache = cache;
+        }
+
+        [HttpGet("new")]
+        [Authorize(Policy = Policies.TopggAuth)]
+        public async Task<IEnumerable<Vote>> New()
+        {
+            var votes = await _cache.GetNewTopGgVotesAsync();
+            if(votes.Count > 0)
+                _logger.LogInformation("Sending {NewTopggVotes} new topgg votes.", votes.Count);
+            
+            return votes;
+        }
+    }
+}
--- a/src/NadekoBot.VotesApi/Controllers/WebhookController.cs
+++ b/src/NadekoBot.VotesApi/Controllers/WebhookController.cs
@@ -0,0 +1,52 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using NadekoBot.VotesApi.Services;
+
+namespace NadekoBot.VotesApi.Controllers
+{
+    [ApiController]
+    public class WebhookController : ControllerBase
+    {
+        private readonly ILogger<WebhookController> _logger;
+        private readonly IVotesCache _votesCache;
+        private readonly IConfiguration _conf;
+
+        public WebhookController(ILogger<WebhookController> logger, IVotesCache votesCache, IConfiguration conf)
+        {
+            _logger = logger;
+            _votesCache = votesCache;
+            _conf = conf;
+        }
+        
+        [HttpPost("/discordswebhook")]
+        [Authorize(Policy = Policies.DiscordsAuth)]
+        public async Task<IActionResult> DiscordsWebhook([FromBody]DiscordsVoteWebhookModel data)
+        {
+
+            _logger.LogInformation("User {UserId} has voted for Bot {BotId} on {Platform}",
+                data.User,
+                data.Bot,
+                "discords.com");
+
+            await _votesCache.AddNewDiscordsVote(data.User);
+            return Ok();
+        }
+
+        [HttpPost("/topggwebhook")]
+        [Authorize(Policy = Policies.TopggAuth)]
+        public async Task<IActionResult> TopggWebhook([FromBody] TopggVoteWebhookModel data)
+        {
+            _logger.LogInformation("User {UserId} has voted for Bot {BotId} on {Platform}",
+                data.User,
+                data.Bot,
+                "top.gg");
+
+            await _votesCache.AddNewTopggVote(data.User);
+            return Ok();
+        }
+    }
+}
--- a/src/NadekoBot.VotesApi/Dockerfile
+++ b/src/NadekoBot.VotesApi/Dockerfile
@@ -0,0 +1,20 @@
+FROM mcr.microsoft.com/dotnet/aspnet:5.0 AS base
+WORKDIR /app
+EXPOSE 80
+EXPOSE 443
+
+FROM mcr.microsoft.com/dotnet/sdk:5.0 AS build
+WORKDIR /src
+COPY ["src/NadekoBot.VotesApi/NadekoBot.VotesApi.csproj", "NadekoBot.VotesApi/"]
+RUN dotnet restore "src/NadekoBot.VotesApi/NadekoBot.VotesApi.csproj"
+COPY . .
+WORKDIR "/src/NadekoBot.VotesApi"
+RUN dotnet build "NadekoBot.VotesApi.csproj" -c Release -o /app/build
+
+FROM build AS publish
+RUN dotnet publish "NadekoBot.VotesApi.csproj" -c Release -o /app/publish
+
+FROM base AS final
+WORKDIR /app
+COPY --from=publish /app/publish .
+ENTRYPOINT ["dotnet", "NadekoBot.VotesApi.dll"]
--- a/src/NadekoBot.VotesApi/NadekoBot.VotesApi.csproj
+++ b/src/NadekoBot.VotesApi/NadekoBot.VotesApi.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+    <PropertyGroup>
+        <TargetFramework>net5.0</TargetFramework>
+        <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="MorseCode.ITask" Version="2.0.3" />
+        <PackageReference Include="Swashbuckle.AspNetCore" Version="5.6.3" />
+    </ItemGroup>
+
+</Project>
--- a/src/NadekoBot.VotesApi/Program.cs
+++ b/src/NadekoBot.VotesApi/Program.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace NadekoBot.VotesApi
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            CreateHostBuilder(args).Build().Run();
+        }
+
+        public static IHostBuilder CreateHostBuilder(string[] args) =>
+            Host.CreateDefaultBuilder(args)
+                .ConfigureWebHostDefaults(webBuilder => { webBuilder.UseStartup<Startup>(); });
+    }
+}
--- a/src/NadekoBot.VotesApi/Properties/launchSettings.json
+++ b/src/NadekoBot.VotesApi/Properties/launchSettings.json
@@ -0,0 +1,31 @@
+{
+  "$schema": "http://json.schemastore.org/launchsettings.json",
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:16451",
+      "sslPort": 44323
+    }
+  },
+  "profiles": {
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "NadekoBot.VotesApi": {
+      "commandName": "Project",
+      "dotnetRunMessages": "true",
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "applicationUrl": "https://localhost:5001;http://localhost:5000",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}
--- a/src/NadekoBot.VotesApi/README.md
+++ b/src/NadekoBot.VotesApi/README.md
@@ -0,0 +1,46 @@
+## Votes Api
+
+This api is used if you want your bot to be able to reward users who vote for it on discords.com or top.gg   
+
+#### [GET] `/discords/new`
+    Get the discords votes received after previous call to this endpoint.
+    Input full url of this endpoint in your creds.yml file under Discords url field.
+    For example "https://api.my.cool.bot/discords/new"
+#### [GET] `/topgg/new`
+    Get the topgg votes received after previous call to this endpoint.
+    Input full url of this endpoint in your creds.yml file under Topgg url field.
+    For example "https://api.my.cool.bot/topgg/new"
+
+#### [POST] `/discordswebhook`
+    Input this endpoint as the webhook on discords.com bot edit page
+    model: https://docs.botsfordiscord.com/methods/receiving-votes
+    For example "https://api.my.cool.bot/topggwebhook"
+#### [POST] `/topggwebhook`
+    Input this endpoint as the webhook https://top.gg/bot/:your-bot-id/webhooks (replace :your-bot-id with your bot's id)
+    model: https://docs.top.gg/resources/webhooks/#schema
+    For example "https://api.my.cool.bot/discordswebhook"
+
+Input your super-secret header value in appsettings.json's DiscordsKey and TopGGKey fields
+They must match your DiscordsKey and TopGG key respectively, as well as your secrets in the discords.com and top.gg webhook setup pages
+
+Full Example:
+
+⚠ Change TopggKey and DiscordsKey to a secure long string  
+⚠ You can use https://www.random.org/strings/?num=1&len=20&digits=on&upperalpha=on&loweralpha=on&unique=on&format=html&rnd=new to generate it
+
+`creds.yml`
+```yml
+votes:
+    TopggServiceUrl: "https://api.my.cool.bot/topgg"
+    TopggKey: "my_topgg_key"
+    DiscordsServiceUrl: "https://api.my.cool.bot/discords"
+    DiscordsKey: "my_discords_key"
+```
+
+`appsettings.json`
+```json
+...
+  "DiscordsKey": "my_discords_key",
+  "TopGGKey": "my_topgg_key",
+...
+```
--- a/src/NadekoBot.VotesApi/Services/FileVotesCache.cs
+++ b/src/NadekoBot.VotesApi/Services/FileVotesCache.cs
@@ -0,0 +1,105 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using System.Threading;
+using MorseCode.ITask;
+
+namespace NadekoBot.VotesApi.Services
+{
+    public class FileVotesCache : IVotesCache
+    {
+        private const string statsFile = "store/stats.json";
+        private const string topggFile = "store/topgg.json";
+        private const string discordsFile = "store/discords.json";
+
+        private readonly SemaphoreSlim locker = new SemaphoreSlim(1, 1);
+
+        public FileVotesCache()
+        {
+            if (!Directory.Exists("store"))
+                Directory.CreateDirectory("store");
+            
+            if(!File.Exists(topggFile))
+                File.WriteAllText(topggFile, "[]");
+            
+            if(!File.Exists(discordsFile))
+                File.WriteAllText(discordsFile, "[]");
+        }
+
+        public ITask AddNewTopggVote(string userId)
+        {
+            return AddNewVote(topggFile, userId);
+        }
+        
+        public ITask AddNewDiscordsVote(string userId)
+        {
+            return AddNewVote(discordsFile, userId);
+        }
+
+        private async ITask AddNewVote(string file, string userId)
+        {
+            await locker.WaitAsync();
+            try
+            {
+                var votes = await GetVotesAsync(file);
+                votes.Add(userId);
+                await File.WriteAllTextAsync(file , JsonSerializer.Serialize(votes));
+            }
+            finally
+            {
+                locker.Release();
+            }
+        }
+
+        public async ITask<IList<Vote>> GetNewTopGgVotesAsync()
+        {
+            var votes = await EvictTopggVotes();
+            return votes;
+        }
+
+        public async ITask<IList<Vote>> GetNewDiscordsVotesAsync()
+        {
+            var votes = await EvictDiscordsVotes();
+            return votes;
+        }
+
+        private ITask<List<Vote>> EvictTopggVotes()
+            => EvictVotes(topggFile);
+
+        private ITask<List<Vote>> EvictDiscordsVotes()
+            => EvictVotes(discordsFile);
+
+        private async ITask<List<Vote>> EvictVotes(string file)
+        {
+            await locker.WaitAsync();
+            try
+            {
+
+                var ids = await GetVotesAsync(file);
+                await File.WriteAllTextAsync(file, "[]");
+                
+                return ids?
+                    .Select(x => (Ok: ulong.TryParse(x, out var r), Id: r))
+                    .Where(x => x.Ok)
+                    .Select(x => new Vote
+                    {
+                        UserId = x.Id
+                    })
+                    .ToList();
+            }
+            finally
+            {
+                locker.Release();
+            }
+        }
+
+        private async ITask<IList<string>> GetVotesAsync(string file)
+        {
+            await using var fs = File.Open(file, FileMode.Open);
+            var votes = await JsonSerializer.DeserializeAsync<List<string>>(fs);
+            return votes;
+        }
+    }
+}
--- a/src/NadekoBot.VotesApi/Services/IVotesCache.cs
+++ b/src/NadekoBot.VotesApi/Services/IVotesCache.cs
@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using MorseCode.ITask;
+
+namespace NadekoBot.VotesApi.Services
+{
+    public interface IVotesCache
+    {
+        ITask<IList<Vote>> GetNewTopGgVotesAsync();
+        ITask<IList<Vote>> GetNewDiscordsVotesAsync();
+        ITask AddNewTopggVote(string userId);
+        ITask AddNewDiscordsVote(string userId);
+    }
+}
--- a/src/NadekoBot.VotesApi/Startup.cs
+++ b/src/NadekoBot.VotesApi/Startup.cs
@@ -0,0 +1,69 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.OpenApi.Models;
+using NadekoBot.VotesApi.Services;
+
+namespace NadekoBot.VotesApi
+{
+    public class Startup
+    {
+        public Startup(IConfiguration configuration)
+        {
+            Configuration = configuration;
+        }
+
+        public IConfiguration Configuration { get; }
+
+        // This method gets called by the runtime. Use this method to add services to the container.
+        public void ConfigureServices(IServiceCollection services)
+        {
+            services.AddControllers();
+            services.AddSingleton<IVotesCache, FileVotesCache>();
+            services.AddSwaggerGen(c =>
+            {
+                c.SwaggerDoc("v1", new OpenApiInfo { Title = "NadekoBot.VotesApi", Version = "v1" });
+            });
+
+            services
+                .AddAuthentication(opts =>
+                {
+                    opts.DefaultScheme = AuthHandler.SchemeName;
+                    opts.AddScheme<AuthHandler>(AuthHandler.SchemeName, AuthHandler.SchemeName);
+                });
+            
+            services
+                .AddAuthorization(opts =>
+                {
+                    opts.DefaultPolicy = new AuthorizationPolicyBuilder(AuthHandler.SchemeName)
+                        .RequireAssertion(x => false)
+                        .Build();
+                    opts.AddPolicy(Policies.DiscordsAuth, policy => policy.RequireClaim(AuthHandler.DiscordsClaim));
+                    opts.AddPolicy(Policies.TopggAuth, policy => policy.RequireClaim(AuthHandler.TopggClaim));
+                });
+        }
+
+        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
+        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
+        {
+            if (env.IsDevelopment())
+            {
+                app.UseDeveloperExceptionPage();
+                app.UseSwagger();
+                app.UseSwaggerUI(c => c.SwaggerEndpoint("/swagger/v1/swagger.json", "NadekoBot.VotesApi v1"));
+            }
+
+            app.UseHttpsRedirection();
+
+            app.UseRouting();
+
+            app.UseAuthentication();
+            app.UseAuthorization();
+
+            app.UseEndpoints(endpoints => { endpoints.MapControllers(); });
+        }
+    }
+}
--- a/src/NadekoBot.VotesApi/WeatherForecast.cs
+++ b/src/NadekoBot.VotesApi/WeatherForecast.cs
@@ -0,0 +1,9 @@
+using System;
+
+namespace NadekoBot.VotesApi
+{
+    public class Vote
+    {
+        public ulong UserId { get; set; }
+    }
+}
--- a/src/NadekoBot.VotesApi/appsettings.Development.json
+++ b/src/NadekoBot.VotesApi/appsettings.Development.json
@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft": "Warning",
+      "Microsoft.Hosting.Lifetime": "Information"
+    }
+  }
+}
--- a/src/NadekoBot.VotesApi/appsettings.json
+++ b/src/NadekoBot.VotesApi/appsettings.json
@@ -0,0 +1,12 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft": "Warning",
+      "Microsoft.Hosting.Lifetime": "Information"
+    }
+  },
+  "DiscordsKey": "my_discords_key",
+  "TopGGKey": "my_topgg_key",
+  "AllowedHosts": "*"
+}
--- a/src/NadekoBot/Bot.cs
+++ b/src/NadekoBot/Bot.cs
@@ -102,7 +102,6 @@ namespace NadekoBot
                .AddSingleton(Client) // discord socket client
                .AddSingleton(_commandService)
                .AddSingleton(this)
-                .AddSingleton<IDataCache, RedisCache>()
                .AddSingleton<ISeria, JsonSeria>()
                .AddSingleton<IPubSub, RedisPubSub>()
                .AddSingleton<IConfigSeria, YamlSeria>()
@@ -132,13 +131,22 @@ namespace NadekoBot
            }
            else
            {
-                svcs.AddSingleton<ICoordinator, RemoteGrpcCoordinator>()
-                    .AddSingleton<IReadyExecutor>(x => (IReadyExecutor)x.GetRequiredService<ICoordinator>());
+                svcs.AddSingleton<RemoteGrpcCoordinator>()
+                    .AddSingleton<ICoordinator>(x => x.GetRequiredService<RemoteGrpcCoordinator>())
+                    .AddSingleton<IReadyExecutor>(x => x.GetRequiredService<RemoteGrpcCoordinator>());
            }

+            svcs.AddSingleton<RedisLocalDataCache>()
+                .AddSingleton<ILocalDataCache>(x => x.GetRequiredService<RedisLocalDataCache>())
+                .AddSingleton<RedisImagesCache>()
+                .AddSingleton<IImageCache>(x => x.GetRequiredService<RedisImagesCache>())
+                .AddSingleton<IReadyExecutor>(x => x.GetRequiredService<RedisImagesCache>())
+                .AddSingleton<IDataCache, RedisCache>();
+            
            svcs.Scan(scan => scan
                .FromAssemblyOf<IReadyExecutor>()
-                .AddClasses(classes => classes.AssignableToAny(
+                .AddClasses(classes => classes
+                        .AssignableToAny(
                    // services
                    typeof(INService),
                    
--- a/src/NadekoBot/Common/Configs/BotConfig.cs
+++ b/src/NadekoBot/Common/Configs/BotConfig.cs
@@ -12,7 +12,7 @@ namespace NadekoBot.Common.Configs
    public sealed partial class BotConfig : ICloneable<BotConfig>
    {
        [Comment(@"DO NOT CHANGE")]
-        public int Version { get; set; }
+        public int Version { get; set; } = 2;

        [Comment(@"Most commands, when executed, have a small colored line
 next to the response. The color depends whether the command
@@ -48,6 +48,11 @@ they will receive this message. Leave empty for no response. The string which wi
 Supports embeds. How it looks: https://puu.sh/B0BLV.png")]
        [YamlMember(ScalarStyle = ScalarStyle.Literal)]
        public string DmHelpText { get; set; }
+        
+        [Comment(@"Only users who send a DM to the bot containing one of the specified words will get a DmHelpText response.
+Case insensitive.
+Leave empty to reply with DmHelpText to every DM.")]
+        public List<string> DmHelpTextKeywords { get; set; }

        [Comment(@"This is the response for the .h command")]
        [YamlMember(ScalarStyle = ScalarStyle.Literal)]
@@ -89,7 +94,6 @@ See RotatingStatuses submodule in Administration.")]

        public BotConfig()
        {
-            Version = 1;
            var color = new ColorConfig();
            Color = color;
            DefaultLocale = new CultureInfo("en-US");
@@ -127,6 +131,14 @@ See RotatingStatuses submodule in Administration.")]
            Prefix = ".";
            RotateStatuses = false;
            GroupGreets = false;
+            DmHelpTextKeywords = new List<string>()
+            {
+                "help",
+                "commands",
+                "cmds",
+                "module",
+                "can you do"
+            };
        }
    }

--- a/src/NadekoBot/Common/Creds.cs
+++ b/src/NadekoBot/Common/Creds.cs
@@ -13,7 +13,7 @@ namespace NadekoBot.Common
            OwnerIds = new List<ulong>();
            TotalShards = 1;
            GoogleApiKey = string.Empty;
-            Votes = new(string.Empty, string.Empty);
+            Votes = new(string.Empty, string.Empty, string.Empty, string.Empty);
            Patreon = new(string.Empty, string.Empty, string.Empty, string.Empty);
            BotListToken = string.Empty;
            CleverbotApiKey = string.Empty;
@@ -77,11 +77,6 @@ Change only if you've changed the coordinator address or port.")]
        public string PatreonCampaignId => Patreon?.CampaignId;
        [YamlIgnore]
        public string PatreonAccessToken => Patreon?.AccessToken;
-
-        [YamlIgnore]
-        public string VotesUrl => Votes?.Url;
-        [YamlIgnore]
-        public string VotesToken => Votes.Key;
        
        [Comment(@"Api key obtained on https://rapidapi.com (go to MyApps -> Add New App -> Enter Name -> Application key)")]
        public string RapidApiKey { get; set; }
@@ -143,19 +138,44 @@ Windows default
                ClientSecret = clientSecret;
                CampaignId = campaignId;
            }
+
+            public PatreonSettings()
+            {
+                
+            }
        }

        public sealed record VotesSettings
        {
-            [Comment(@"")]
-            public string Url { get; set; }
-            [Comment(@"")]
-            public string Key { get; set; }
+            [Comment(@"top.gg votes service url
+This is the url of your instance of the NadekoBot.Votes api
+Example: https://votes.my.cool.bot.com")]
+            public string TopggServiceUrl { get; set; }
+            
+            [Comment(@"Authorization header value sent to the TopGG service url with each request
+This should be equivalent to the TopggKey in your NadekoBot.Votes api appsettings.json file")]
+            public string TopggKey { get; set; }
+            
+            [Comment(@"discords.com votes service url
+This is the url of your instance of the NadekoBot.Votes api
+Example: https://votes.my.cool.bot.com")]
+            public string DiscordsServiceUrl { get; set; }
+            
+            [Comment(@"Authorization header value sent to the Discords service url with each request
+This should be equivalent to the DiscordsKey in your NadekoBot.Votes api appsettings.json file")]
+            public string DiscordsKey { get; set; }

-            public VotesSettings(string url, string key)
+            public VotesSettings()
            {
-                Url = url;
-                Key = key;
+                
+            }
+            
+            public VotesSettings(string topggServiceUrl, string topggKey, string discordsServiceUrl, string discordsKey)
+            {
+                TopggServiceUrl = topggServiceUrl;
+                TopggKey = topggKey;
+                DiscordsServiceUrl = discordsServiceUrl;
+                DiscordsKey = discordsKey;
            }
        }

--- a/src/NadekoBot/Common/IBotCredentials.cs
+++ b/src/NadekoBot/Common/IBotCredentials.cs
@@ -20,8 +20,7 @@ namespace NadekoBot
        string PatreonCampaignId { get; }
        string CleverbotApiKey { get; }
        RestartConfig RestartCommand { get; }
-        string VotesUrl { get; }
-        string VotesToken { get; }
+        Creds.VotesSettings Votes { get; }
        string BotListToken { get; }
        string RedisOptions { get; }
        string LocationIqApiKey { get; }
--- a/src/NadekoBot/Common/ImageUrls.cs
+++ b/src/NadekoBot/Common/ImageUrls.cs
@@ -1,9 +1,11 @@
 using System;
+using NadekoBot.Common.Yml;

 namespace NadekoBot.Common
 {
    public class ImageUrls
    {
+        [Comment("DO NOT CHANGE")]
        public int Version { get; set; } = 2;

        public CoinData Coins { get; set; }
--- a/src/NadekoBot/Common/OldImageUrls.cs
+++ b/src/NadekoBot/Common/OldImageUrls.cs
@@ -0,0 +1,49 @@
+using System;
+
+namespace NadekoBot.Common
+{
+    public class OldImageUrls
+    {
+        public int Version { get; set; } = 2;
+
+        public CoinData Coins { get; set; }
+        public Uri[] Currency { get; set; }
+        public Uri[] Dice { get; set; }
+        public RategirlData Rategirl { get; set; }
+        public XpData Xp { get; set; }
+
+        //new
+        public RipData Rip { get; set; }
+        public SlotData Slots { get; set; }
+
+        public class RipData
+        {
+            public Uri Bg { get; set; }
+            public Uri Overlay { get; set; }
+        }
+
+        public class SlotData
+        {
+            public Uri[] Emojis { get; set; }
+            public Uri[] Numbers { get; set; }
+            public Uri Bg { get; set; }
+        }
+
+        public class CoinData
+        {
+            public Uri[] Heads { get; set; }
+            public Uri[] Tails { get; set; }
+        }
+
+        public class RategirlData
+        {
+            public Uri Matrix { get; set; }
+            public Uri Dot { get; set; }
+        }
+
+        public class XpData
+        {
+            public Uri Bg { get; set; }
+        }
+    }
+}
--- a/src/NadekoBot/Common/Replacements/ReplacementBuilder.cs
+++ b/src/NadekoBot/Common/Replacements/ReplacementBuilder.cs
@@ -89,6 +89,8 @@ namespace NadekoBot.Common.Replacements
            _reps.TryAdd("%server.id%", () => g is null ? "DM" : g.Id.ToString());
            _reps.TryAdd("%server.name%", () => g is null ? "DM" : g.Name);
            _reps.TryAdd("%server.members%", () => g != null && g is SocketGuild sg ? sg.MemberCount.ToString() : "?");
+            _reps.TryAdd("%server.boosters%", () => g.PremiumSubscriptionCount.ToString());
+            _reps.TryAdd("%server.boost_level%", () => ((int)g.PremiumTier).ToString());
            _reps.TryAdd("%server.time%", () =>
            {
                TimeZoneInfo to = TimeZoneInfo.Local;
@@ -175,13 +177,13 @@ namespace NadekoBot.Common.Replacements
            /*OBSOLETE*/
            _reps.TryAdd("%servers%", () => c.Guilds.Count.ToString());
 #if !GLOBAL_NADEKO
-            _reps.TryAdd("%users%", () => c.Guilds.Sum(s => s.Users.Count).ToString());
+            _reps.TryAdd("%users%", () => c.Guilds.Sum(g => g.MemberCount).ToString());
 #endif

            /*NEW*/
            _reps.TryAdd("%shard.servercount%", () => c.Guilds.Count.ToString());
 #if !GLOBAL_NADEKO
-            _reps.TryAdd("%shard.usercount%", () => c.Guilds.Sum(s => s.Users.Count).ToString());
+            _reps.TryAdd("%shard.usercount%", () => c.Guilds.Sum(g => g.MemberCount).ToString());
 #endif
            _reps.TryAdd("%shard.id%", () => c.ShardId.ToString());
            return this;
--- a/src/NadekoBot/Common/Replacements/Replacer.cs
+++ b/src/NadekoBot/Common/Replacements/Replacer.cs
@@ -53,6 +53,7 @@ namespace NadekoBot.Common.Replacements
            newEmbedData.Title = Replace(embedData.Title);
            newEmbedData.Thumbnail = Replace(embedData.Thumbnail);
            newEmbedData.Image = Replace(embedData.Image);
+            newEmbedData.Url = Replace(embedData.Url);
            if (embedData.Author != null)
            {
                newEmbedData.Author = new SmartTextEmbedAuthor();
@@ -68,6 +69,7 @@ namespace NadekoBot.Common.Replacements
                    var newF = new SmartTextEmbedField();
                    newF.Name = Replace(f.Name);
                    newF.Value = Replace(f.Value);
+                    newF.Inline = f.Inline;
                    fields.Add(newF);
                }

--- a/src/NadekoBot/Common/Yml/Yaml.cs
+++ b/src/NadekoBot/Common/Yml/Yaml.cs
@@ -20,6 +20,7 @@ namespace NadekoBot.Common.Yml
            .WithTypeConverter(new Rgba32Converter())
            .WithTypeConverter(new CultureInfoConverter())
            .WithTypeConverter(new UriConverter())
+            .IgnoreUnmatchedProperties()
            .Build();
    }
 }
--- a/src/NadekoBot/Db/Extensions/DiscordUserExtensions.cs
+++ b/src/NadekoBot/Db/Extensions/DiscordUserExtensions.cs
@@ -138,14 +138,15 @@ WHERE UserId={userId};");
            // just update the amount, there is no new user data
            if (!updatedUserData)
            {
-                ctx.Database.ExecuteSqlInterpolated($@"
+                var rows = ctx.Database.ExecuteSqlInterpolated($@"
 UPDATE OR IGNORE DiscordUser
 SET CurrencyAmount=CurrencyAmount+{amount}
 WHERE UserId={userId};

-INSERT OR IGNORE INTO DiscordUser (UserId, Username, Discriminator, AvatarId, CurrencyAmount)
-VALUES ({userId}, {name}, {discrim}, {avatarId}, {amount});
+INSERT OR IGNORE INTO DiscordUser (UserId, Username, Discriminator, AvatarId, CurrencyAmount, TotalXp)
+VALUES ({userId}, {name}, {discrim}, {avatarId}, {amount}, 0);
 ");
+                
            }
            else
            {
@@ -157,8 +158,8 @@ SET CurrencyAmount=CurrencyAmount+{amount},
    AvatarId={avatarId}
 WHERE UserId={userId};

-INSERT OR IGNORE INTO DiscordUser (UserId, Username, Discriminator, AvatarId, CurrencyAmount)
-VALUES ({userId}, {name}, {discrim}, {avatarId}, {amount});
+INSERT OR IGNORE INTO DiscordUser (UserId, Username, Discriminator, AvatarId, CurrencyAmount, TotalXp)
+VALUES ({userId}, {name}, {discrim}, {avatarId}, {amount}, 0);
 ");
            }
            return true;
--- a/src/NadekoBot/Db/Extensions/GuildConfigExtensions.cs
+++ b/src/NadekoBot/Db/Extensions/GuildConfigExtensions.cs
@@ -48,12 +48,12 @@ namespace NadekoBot.Db

        private static IQueryable<GuildConfig> IncludeEverything(this DbSet<GuildConfig> configs)
        {
+            // todo split query
            return configs
                    .AsQueryable()
                    .Include(gc => gc.CommandCooldowns)
                    .Include(gc => gc.FollowedStreams)
                    .Include(gc => gc.StreamRole)
-                    .Include(gc => gc.NsfwBlacklistedTags)
                    .Include(gc => gc.XpSettings)
                    .ThenInclude(x => x.ExclusionList)
                    .Include(gc => gc.DelMsgOnCmdChannels)
@@ -117,9 +117,18 @@ namespace NadekoBot.Db
        {
            var logSetting = ctx.LogSettings
                .AsQueryable()
-                .Include(x => x.IgnoredChannels)
+                .Include(x => x.LogIgnores)
                .Where(x => x.GuildId == guildId)
                .FirstOrDefault();
+
+            if (logSetting is null)
+            {
+                ctx.LogSettings.Add(logSetting = new ()
+                {
+                    GuildId = guildId
+                });
+                ctx.SaveChanges();
+            }
            
            return logSetting;
        }
--- a/src/NadekoBot/Db/Models/GuildConfig.cs
+++ b/src/NadekoBot/Db/Models/GuildConfig.cs
@@ -91,7 +91,6 @@ namespace NadekoBot.Services.Database.Models
        public bool WarningsInitialized { get; set; }
        public HashSet<SlowmodeIgnoredUser> SlowmodeIgnoredUsers { get; set; }
        public HashSet<SlowmodeIgnoredRole> SlowmodeIgnoredRoles { get; set; }
-        public HashSet<NsfwBlacklitedTag> NsfwBlacklistedTags { get; set; } = new HashSet<NsfwBlacklitedTag>();

        public List<ShopEntry> ShopEntries { get; set; }
        public ulong? GameVoiceChannel { get; set; } = null;
--- a/src/NadekoBot/Db/Models/IgnoredLogChannel.cs
+++ b/src/NadekoBot/Db/Models/IgnoredLogChannel.cs
@@ -1,8 +0,0 @@
-namespace NadekoBot.Services.Database.Models
-{
-    public class IgnoredLogChannel : DbEntity
-    {
-        public LogSetting LogSetting { get; set; }
-        public ulong ChannelId { get; set; }
-    }
-}
--- a/src/NadekoBot/Db/Models/IgnoredLogItem.cs
+++ b/src/NadekoBot/Db/Models/IgnoredLogItem.cs
@@ -0,0 +1,16 @@
+namespace NadekoBot.Services.Database.Models
+{
+    public class IgnoredLogItem : DbEntity
+    {
+        public int LogSettingId { get; set; }
+        public LogSetting LogSetting { get; set; }
+        public ulong LogItemId { get; set; }
+        public IgnoredItemType ItemType { get; set; }
+    }
+
+    public enum IgnoredItemType
+    {
+        Channel,
+        User,
+    }
+}
--- a/src/NadekoBot/Db/Models/LogSetting.cs
+++ b/src/NadekoBot/Db/Models/LogSetting.cs
@@ -4,8 +4,7 @@ namespace NadekoBot.Services.Database.Models
 {
    public class LogSetting : DbEntity
    {
-        public HashSet<IgnoredLogChannel> IgnoredChannels { get; set; } = new HashSet<IgnoredLogChannel>();
-        public HashSet<IgnoredVoicePresenceChannel> IgnoredVoicePresenceChannelIds { get; set; } = new HashSet<IgnoredVoicePresenceChannel>();
+        public List<IgnoredLogItem> LogIgnores { get; set; } = new List<IgnoredLogItem>();

        public ulong GuildId { get; set; }
        public ulong? LogOtherId { get; set; }
--- a/src/NadekoBot/Db/Models/NsfwBlacklistedTag.cs
+++ b/src/NadekoBot/Db/Models/NsfwBlacklistedTag.cs
@@ -0,0 +1,16 @@
+using System;
+
+namespace NadekoBot.Services.Database.Models
+{
+    public class NsfwBlacklistedTag : DbEntity
+    {
+        public ulong GuildId { get; set; }
+        public string Tag { get; set; }
+
+        public override int GetHashCode() 
+            => Tag.GetHashCode(StringComparison.InvariantCulture);
+
+        public override bool Equals(object obj) 
+            => obj is NsfwBlacklistedTag x && x.Tag == Tag;
+    }
+}
--- a/src/NadekoBot/Db/Models/NsfwBlacklitedTag.cs
+++ b/src/NadekoBot/Db/Models/NsfwBlacklitedTag.cs
@@ -1,21 +0,0 @@
-using System;
-
-namespace NadekoBot.Services.Database.Models
-{
-    public class NsfwBlacklitedTag : DbEntity
-    {
-        public string Tag { get; set; }
-
-        public override int GetHashCode()
-        {
-            return Tag.GetHashCode(StringComparison.InvariantCulture);
-        }
-
-        public override bool Equals(object obj)
-        {
-            return obj is NsfwBlacklitedTag x
-                ? x.Tag == Tag
-                : false;
-        }
-    }
-}
--- a/src/NadekoBot/Db/NadekoContext.cs
+++ b/src/NadekoBot/Db/NadekoContext.cs
@@ -42,8 +42,8 @@ namespace NadekoBot.Services.Database

        //logging
        public DbSet<LogSetting> LogSettings { get; set; }
-        public DbSet<IgnoredLogChannel> IgnoredLogChannels { get; set; }
        public DbSet<IgnoredVoicePresenceChannel> IgnoredVoicePresenceCHannels { get; set; }
+        public DbSet<IgnoredLogItem> IgnoredLogChannels { get; set; }

        public DbSet<RotatingPlayingStatus> RotatingStatus { get; set; }
        public DbSet<BlacklistEntry> Blacklist { get; set; }
@@ -59,6 +59,7 @@ namespace NadekoBot.Services.Database
        public DbSet<Poll> Poll { get; set; }
        public DbSet<WaifuInfo> WaifuInfo { get; set; }
        public DbSet<ImageOnlyChannel> ImageOnlyChannels { get; set; }
+        public DbSet<NsfwBlacklistedTag> NsfwBlacklistedTags { get; set; }

        public NadekoContext(DbContextOptions<NadekoContext> options) : base(options)
        {
@@ -342,12 +343,25 @@ namespace NadekoBot.Services.Database
            modelBuilder.Entity<LogSetting>(ls => ls
                .HasIndex(x => x.GuildId)
                .IsUnique());
+            
+            modelBuilder.Entity<LogSetting>(ls => ls
+                .HasMany(x => x.LogIgnores)
+                .WithOne(x => x.LogSetting)
+                .OnDelete(DeleteBehavior.Cascade));
+
+            modelBuilder.Entity<IgnoredLogItem>(ili => ili
+                .HasIndex(x => new { x.LogSettingId, x.LogItemId, x.ItemType })
+                .IsUnique());

            #endregion

            modelBuilder.Entity<ImageOnlyChannel>(ioc => ioc
                .HasIndex(x => x.ChannelId)
                .IsUnique());
+
+            modelBuilder.Entity<NsfwBlacklistedTag>(nbt => nbt
+                .HasIndex(x => x.GuildId)
+                .IsUnique(false));
        }
    }
 }
--- a/src/NadekoBot/Migrations/20210921204645_logignore-user-channel.Designer.cs
+++ b/src/NadekoBot/Migrations/20210921204645_logignore-user-channel.Designer.cs
--- a/src/NadekoBot/Migrations/20210921204645_logignore-user-channel.cs
+++ b/src/NadekoBot/Migrations/20210921204645_logignore-user-channel.cs
@@ -0,0 +1,97 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace NadekoBot.Migrations
+{
+    public partial class logignoreuserchannel : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql("DELETE FROM IgnoredLogChannels WHERE LogSettingId is NULL");
+            
+            migrationBuilder.DropForeignKey(
+                name: "FK_IgnoredLogChannels_LogSettings_LogSettingId",
+                table: "IgnoredLogChannels");
+
+            migrationBuilder.DropIndex(
+                name: "IX_IgnoredLogChannels_LogSettingId",
+                table: "IgnoredLogChannels");
+
+            migrationBuilder.RenameColumn(
+                name: "ChannelId",
+                table: "IgnoredLogChannels",
+                newName: "LogItemId");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "LogSettingId",
+                table: "IgnoredLogChannels",
+                type: "INTEGER",
+                nullable: false,
+                defaultValue: 0,
+                oldClrType: typeof(int),
+                oldType: "INTEGER",
+                oldNullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "ItemType",
+                table: "IgnoredLogChannels",
+                type: "INTEGER",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_IgnoredLogChannels_LogSettingId_LogItemId_ItemType",
+                table: "IgnoredLogChannels",
+                columns: new[] { "LogSettingId", "LogItemId", "ItemType" },
+                unique: true);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_IgnoredLogChannels_LogSettings_LogSettingId",
+                table: "IgnoredLogChannels",
+                column: "LogSettingId",
+                principalTable: "LogSettings",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_IgnoredLogChannels_LogSettings_LogSettingId",
+                table: "IgnoredLogChannels");
+
+            migrationBuilder.DropIndex(
+                name: "IX_IgnoredLogChannels_LogSettingId_LogItemId_ItemType",
+                table: "IgnoredLogChannels");
+
+            migrationBuilder.DropColumn(
+                name: "ItemType",
+                table: "IgnoredLogChannels");
+
+            migrationBuilder.RenameColumn(
+                name: "LogItemId",
+                table: "IgnoredLogChannels",
+                newName: "ChannelId");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "LogSettingId",
+                table: "IgnoredLogChannels",
+                type: "INTEGER",
+                nullable: true,
+                oldClrType: typeof(int),
+                oldType: "INTEGER");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_IgnoredLogChannels_LogSettingId",
+                table: "IgnoredLogChannels",
+                column: "LogSettingId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_IgnoredLogChannels_LogSettings_LogSettingId",
+                table: "IgnoredLogChannels",
+                column: "LogSettingId",
+                principalTable: "LogSettings",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Restrict);
+        }
+    }
+}
--- a/src/NadekoBot/Migrations/20211015232708_nsfw-blacklist-tags.Designer.cs
+++ b/src/NadekoBot/Migrations/20211015232708_nsfw-blacklist-tags.Designer.cs
--- a/src/NadekoBot/Migrations/20211015232708_nsfw-blacklist-tags.cs
+++ b/src/NadekoBot/Migrations/20211015232708_nsfw-blacklist-tags.cs
@@ -0,0 +1,76 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace NadekoBot.Migrations
+{
+    public partial class nsfwblacklisttags : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+
+            migrationBuilder.CreateTable(
+                name: "NsfwBlacklistedTags",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    GuildId = table.Column<ulong>(type: "INTEGER", nullable: false),
+                    Tag = table.Column<string>(type: "TEXT", nullable: true),
+                    DateAdded = table.Column<DateTime>(type: "TEXT", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_NsfwBlacklistedTags", x => x.Id);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_NsfwBlacklistedTags_GuildId",
+                table: "NsfwBlacklistedTags",
+                column: "GuildId");
+
+            migrationBuilder.Sql(@"INSERT INTO NsfwBlacklistedTags(Id, GuildId, Tag, DateAdded)
+SELECT 
+    Id,
+    (SELECT GuildId From GuildConfigs WHERE Id=GuildConfigId),
+    Tag,
+    DateAdded
+FROM NsfwBlacklitedTag
+WHERE GuildConfigId in (SELECT Id from GuildConfigs);");
+            
+            migrationBuilder.DropTable(
+                name: "NsfwBlacklitedTag");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "NsfwBlacklistedTags");
+
+            migrationBuilder.CreateTable(
+                name: "NsfwBlacklitedTag",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    DateAdded = table.Column<DateTime>(type: "TEXT", nullable: true),
+                    GuildConfigId = table.Column<int>(type: "INTEGER", nullable: true),
+                    Tag = table.Column<string>(type: "TEXT", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_NsfwBlacklitedTag", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_NsfwBlacklitedTag_GuildConfigs_GuildConfigId",
+                        column: x => x.GuildConfigId,
+                        principalTable: "GuildConfigs",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_NsfwBlacklitedTag_GuildConfigId",
+                table: "NsfwBlacklitedTag",
+                column: "GuildConfigId");
+        }
+    }
+}
--- a/src/NadekoBot/Migrations/NadekoContextModelSnapshot.cs
+++ b/src/NadekoBot/Migrations/NadekoContextModelSnapshot.cs
@@ -187,29 +187,6 @@ namespace NadekoBot.Migrations
                    b.ToTable("FollowedStream");
                });

-            modelBuilder.Entity("NadekoBot.Services.Database.ImageOnlyChannel", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER");
-
-                    b.Property<ulong>("ChannelId")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<DateTime?>("DateAdded")
-                        .HasColumnType("TEXT");
-
-                    b.Property<ulong>("GuildId")
-                        .HasColumnType("INTEGER");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ChannelId")
-                        .IsUnique();
-
-                    b.ToTable("ImageOnlyChannels");
-                });
-
            modelBuilder.Entity("NadekoBot.Services.Database.Models.AntiAltSetting", b =>
                {
                    b.Property<int>("Id")
@@ -870,24 +847,28 @@ namespace NadekoBot.Migrations
                    b.ToTable("GuildConfigs");
                });

-            modelBuilder.Entity("NadekoBot.Services.Database.Models.IgnoredLogChannel", b =>
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.IgnoredLogItem", b =>
                {
                    b.Property<int>("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("INTEGER");

-                    b.Property<ulong>("ChannelId")
-                        .HasColumnType("INTEGER");
-
                    b.Property<DateTime?>("DateAdded")
                        .HasColumnType("TEXT");

-                    b.Property<int?>("LogSettingId")
+                    b.Property<int>("ItemType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<ulong>("LogItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LogSettingId")
                        .HasColumnType("INTEGER");

                    b.HasKey("Id");

-                    b.HasIndex("LogSettingId");
+                    b.HasIndex("LogSettingId", "LogItemId", "ItemType")
+                        .IsUnique();

                    b.ToTable("IgnoredLogChannels");
                });
@@ -914,6 +895,29 @@ namespace NadekoBot.Migrations
                    b.ToTable("IgnoredVoicePresenceCHannels");
                });

+            modelBuilder.Entity("NadekoBot.Services.Database.Models.ImageOnlyChannel", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<ulong>("ChannelId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<ulong>("GuildId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChannelId")
+                        .IsUnique();
+
+                    b.ToTable("ImageOnlyChannels");
+                });
+
            modelBuilder.Entity("NadekoBot.Services.Database.Models.LogSetting", b =>
                {
                    b.Property<int>("Id")
@@ -1058,7 +1062,7 @@ namespace NadekoBot.Migrations
                    b.ToTable("MutedUserId");
                });

-            modelBuilder.Entity("NadekoBot.Services.Database.Models.NsfwBlacklitedTag", b =>
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.NsfwBlacklistedTag", b =>
                {
                    b.Property<int>("Id")
                        .ValueGeneratedOnAdd()
@@ -1067,7 +1071,7 @@ namespace NadekoBot.Migrations
                    b.Property<DateTime?>("DateAdded")
                        .HasColumnType("TEXT");

-                    b.Property<int?>("GuildConfigId")
+                    b.Property<ulong>("GuildId")
                        .HasColumnType("INTEGER");

                    b.Property<string>("Tag")
@@ -1075,9 +1079,9 @@ namespace NadekoBot.Migrations

                    b.HasKey("Id");

-                    b.HasIndex("GuildConfigId");
+                    b.HasIndex("GuildId");

-                    b.ToTable("NsfwBlacklitedTag");
+                    b.ToTable("NsfwBlacklistedTags");
                });

            modelBuilder.Entity("NadekoBot.Services.Database.Models.Permissionv2", b =>
@@ -2269,11 +2273,13 @@ namespace NadekoBot.Migrations
                    b.Navigation("GuildConfig");
                });

-            modelBuilder.Entity("NadekoBot.Services.Database.Models.IgnoredLogChannel", b =>
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.IgnoredLogItem", b =>
                {
                    b.HasOne("NadekoBot.Services.Database.Models.LogSetting", "LogSetting")
-                        .WithMany("IgnoredChannels")
-                        .HasForeignKey("LogSettingId");
+                        .WithMany("LogIgnores")
+                        .HasForeignKey("LogSettingId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();

                    b.Navigation("LogSetting");
                });
@@ -2281,7 +2287,7 @@ namespace NadekoBot.Migrations
            modelBuilder.Entity("NadekoBot.Services.Database.Models.IgnoredVoicePresenceChannel", b =>
                {
                    b.HasOne("NadekoBot.Services.Database.Models.LogSetting", "LogSetting")
-                        .WithMany("IgnoredVoicePresenceChannelIds")
+                        .WithMany()
                        .HasForeignKey("LogSettingId");

                    b.Navigation("LogSetting");
@@ -2294,13 +2300,6 @@ namespace NadekoBot.Migrations
                        .HasForeignKey("GuildConfigId");
                });

-            modelBuilder.Entity("NadekoBot.Services.Database.Models.NsfwBlacklitedTag", b =>
-                {
-                    b.HasOne("NadekoBot.Services.Database.Models.GuildConfig", null)
-                        .WithMany("NsfwBlacklistedTags")
-                        .HasForeignKey("GuildConfigId");
-                });
-
            modelBuilder.Entity("NadekoBot.Services.Database.Models.Permissionv2", b =>
                {
                    b.HasOne("NadekoBot.Services.Database.Models.GuildConfig", null)
@@ -2567,8 +2566,6 @@ namespace NadekoBot.Migrations

                    b.Navigation("MutedUsers");

-                    b.Navigation("NsfwBlacklistedTags");
-
                    b.Navigation("Permissions");

                    b.Navigation("ReactionRoleMessages");
@@ -2598,9 +2595,7 @@ namespace NadekoBot.Migrations

            modelBuilder.Entity("NadekoBot.Services.Database.Models.LogSetting", b =>
                {
-                    b.Navigation("IgnoredChannels");
-
-                    b.Navigation("IgnoredVoicePresenceChannelIds");
+                    b.Navigation("LogIgnores");
                });

            modelBuilder.Entity("NadekoBot.Services.Database.Models.MusicPlaylist", b =>
--- a/src/NadekoBot/Modules/Administration/AutoAssignRoleCommands.cs
+++ b/src/NadekoBot/Modules/Administration/AutoAssignRoleCommands.cs
@@ -16,6 +16,7 @@ namespace NadekoBot.Modules.Administration
            [NadekoCommand, Aliases]
            [RequireContext(ContextType.Guild)]
            [UserPerm(GuildPerm.ManageRoles)]
+            [BotPerm(GuildPerm.ManageRoles)]
            public async Task AutoAssignRole([Leftover] IRole role)
            {
                var guser = (IGuildUser) ctx.User;
@@ -47,6 +48,7 @@ namespace NadekoBot.Modules.Administration
            [NadekoCommand, Aliases]
            [RequireContext(ContextType.Guild)]
            [UserPerm(GuildPerm.ManageRoles)]
+            [BotPerm(GuildPerm.ManageRoles)]
            public async Task AutoAssignRole()
            {
                if (!_service.TryGetRoles(ctx.Guild.Id, out var roles))
--- a/src/NadekoBot/Modules/Administration/LogCommands.cs
+++ b/src/NadekoBot/Modules/Administration/LogCommands.cs
@@ -7,6 +7,7 @@ using NadekoBot.Services.Database.Models;
 using NadekoBot.Extensions;
 using NadekoBot.Modules.Administration.Services;
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;

@@ -18,12 +19,6 @@ namespace NadekoBot.Modules.Administration
        [NoPublicBot]
        public class LogCommands : NadekoSubmodule<ILogCommandService>
        {
-            public enum EnableDisable
-            {
-                Enable,
-                Disable
-            }
-
            [NadekoCommand, Aliases]
            [RequireContext(ContextType.Guild)]
            [UserPerm(GuildPerm.Administrator)]
@@ -43,14 +38,51 @@ namespace NadekoBot.Modules.Administration
            [OwnerOnly]
            public async Task LogIgnore()
            {
-                var channel = (ITextChannel)ctx.Channel;
+                var settings = _service.GetGuildLogSettings(ctx.Guild.Id);

-                var removed = _service.LogIgnore(ctx.Guild.Id, ctx.Channel.Id);
+                var chs = settings?.LogIgnores.Where(x => x.ItemType == IgnoredItemType.Channel).ToList()
+                    ?? new List<IgnoredLogItem>();
+                var usrs = settings?.LogIgnores.Where(x => x.ItemType == IgnoredItemType.User).ToList()
+                    ?? new List<IgnoredLogItem>();
+
+                var eb = _eb.Create(ctx)
+                    .WithOkColor()
+                    .AddField(GetText(strs.log_ignored_channels),
+                        chs.Count == 0 ? "-" : string.Join('\n', chs.Select(x => $"{x.LogItemId} | <#{x.LogItemId}>")))
+                    .AddField(GetText(strs.log_ignored_users),
+                        usrs.Count == 0 ? "-" : string.Join('\n', usrs.Select(x => $"{x.LogItemId} | <@{x.LogItemId}>")));
+
+                await ctx.Channel.EmbedAsync(eb);
+            }
+
+            [NadekoCommand, Aliases]
+            [RequireContext(ContextType.Guild)]
+            [UserPerm(GuildPerm.Administrator)]
+            [OwnerOnly]
+            public async Task LogIgnore([Leftover]ITextChannel target)
+            {
+                target ??= (ITextChannel)ctx.Channel;
+
+                var removed = _service.LogIgnore(ctx.Guild.Id, target.Id, IgnoredItemType.Channel);

                if (!removed)
-                    await ReplyConfirmLocalizedAsync(strs.log_ignore(Format.Bold(channel.Mention + "(" + channel.Id + ")"))).ConfigureAwait(false);
+                    await ReplyConfirmLocalizedAsync(strs.log_ignore_chan(Format.Bold(target.Mention + "(" + target.Id + ")"))).ConfigureAwait(false);
                else
-                    await ReplyConfirmLocalizedAsync(strs.log_not_ignore(Format.Bold(channel.Mention + "(" + channel.Id + ")"))).ConfigureAwait(false);
+                    await ReplyConfirmLocalizedAsync(strs.log_not_ignore_chan(Format.Bold(target.Mention + "(" + target.Id + ")"))).ConfigureAwait(false);
+            }
+            
+            [NadekoCommand, Aliases]
+            [RequireContext(ContextType.Guild)]
+            [UserPerm(GuildPerm.Administrator)]
+            [OwnerOnly]
+            public async Task LogIgnore([Leftover]IUser target)
+            {
+                var removed = _service.LogIgnore(ctx.Guild.Id, target.Id, IgnoredItemType.User);
+
+                if (!removed)
+                    await ReplyConfirmLocalizedAsync(strs.log_ignore_user(Format.Bold(target.Mention + "(" + target.Id + ")"))).ConfigureAwait(false);
+                else
+                    await ReplyConfirmLocalizedAsync(strs.log_not_ignore_user(Format.Bold(target.Mention + "(" + target.Id + ")"))).ConfigureAwait(false);
            }

            [NadekoCommand, Aliases]
--- a/src/NadekoBot/Modules/Administration/MuteCommands.cs
+++ b/src/NadekoBot/Modules/Administration/MuteCommands.cs
@@ -90,7 +90,7 @@ namespace NadekoBot.Modules.Administration
                        return;

                    await _service.TimedMute(user, ctx.User, time.Time, reason: reason).ConfigureAwait(false);
-                    await ReplyErrorLocalizedAsync(strs.user_muted_time(Format.Bold(user.ToString()), (int)time.Time.TotalMinutes));
+                    await ReplyConfirmLocalizedAsync(strs.user_muted_time(Format.Bold(user.ToString()), (int)time.Time.TotalMinutes));
                }
                catch (Exception ex)
                {
@@ -150,7 +150,7 @@ namespace NadekoBot.Modules.Administration
                        return;

                    await _service.TimedMute(user, ctx.User, time.Time, MuteType.Chat, reason: reason).ConfigureAwait(false);
-                    await ReplyErrorLocalizedAsync(strs.user_chat_mute_time(Format.Bold(user.ToString()), (int)time.Time.TotalMinutes));
+                    await ReplyConfirmLocalizedAsync(strs.user_chat_mute_time(Format.Bold(user.ToString()), (int)time.Time.TotalMinutes));
                }
                catch (Exception ex)
                {
@@ -209,7 +209,7 @@ namespace NadekoBot.Modules.Administration
                        return;

                    await _service.TimedMute(user, ctx.User, time.Time, MuteType.Voice, reason: reason).ConfigureAwait(false);
-                    await ReplyErrorLocalizedAsync(strs.user_voice_mute_time(Format.Bold(user.ToString()), (int)time.Time.TotalMinutes));
+                    await ReplyConfirmLocalizedAsync(strs.user_voice_mute_time(Format.Bold(user.ToString()), (int)time.Time.TotalMinutes));
                }
                catch
                {
--- a/src/NadekoBot/Modules/Administration/PlayingRotateCommands.cs
+++ b/src/NadekoBot/Modules/Administration/PlayingRotateCommands.cs
@@ -61,7 +61,7 @@ namespace NadekoBot.Modules.Administration
                if (msg is null)
                    return;

-                await ReplyErrorLocalizedAsync(strs.reprm(msg));
+                await ReplyConfirmLocalizedAsync(strs.reprm(msg));
            }
        }
    }
--- a/src/NadekoBot/Modules/Administration/ProtectionCommands.cs
+++ b/src/NadekoBot/Modules/Administration/ProtectionCommands.cs
@@ -28,7 +28,7 @@ namespace NadekoBot.Modules.Administration
                    return;
                }

-                await ReplyErrorLocalizedAsync(strs.protection_not_running("Anti-Alt"));
+                await ReplyConfirmLocalizedAsync(strs.protection_not_running("Anti-Alt"));
            }

            [NadekoCommand, Aliases]
@@ -69,11 +69,11 @@ namespace NadekoBot.Modules.Administration
            {
                if (_service.TryStopAntiRaid(ctx.Guild.Id))
                {
-                    return ReplyErrorLocalizedAsync(strs.prot_disable("Anti-Raid"));
+                    return ReplyConfirmLocalizedAsync(strs.prot_disable("Anti-Raid"));
                }
                else
                {
-                    return ReplyErrorLocalizedAsync(strs.protection_not_running("Anti-Raid"));
+                    return ReplyPendingLocalizedAsync(strs.protection_not_running("Anti-Raid"));
                }
            }

@@ -145,11 +145,11 @@ namespace NadekoBot.Modules.Administration
            {
                if (_service.TryStopAntiSpam(ctx.Guild.Id))
                {
-                    return ReplyErrorLocalizedAsync(strs.prot_disable("Anti-Spam"));
+                    return ReplyConfirmLocalizedAsync(strs.prot_disable("Anti-Spam"));
                }
                else
                {
-                    return ReplyErrorLocalizedAsync(strs.protection_not_running("Anti-Spam"));
+                    return ReplyPendingLocalizedAsync(strs.protection_not_running("Anti-Spam"));
                }
            }
            
--- a/src/NadekoBot/Modules/Administration/RoleCommands.cs
+++ b/src/NadekoBot/Modules/Administration/RoleCommands.cs
@@ -189,7 +189,7 @@ namespace NadekoBot.Modules.Administration
                index--;
                var rr = rrs[index];
                _service.Remove(ctx.Guild.Id, index);
-                await ReplyErrorLocalizedAsync(strs.reaction_role_removed(index + 1));
+                await ReplyConfirmLocalizedAsync(strs.reaction_role_removed(index + 1));
            }

            [NadekoCommand, Aliases]
--- a/src/NadekoBot/Modules/Administration/SelfAssignedRolesCommands.cs
+++ b/src/NadekoBot/Modules/Administration/SelfAssignedRolesCommands.cs
@@ -24,11 +24,11 @@ namespace NadekoBot.Modules.Administration

                if (newVal)
                {
-                    await ReplyErrorLocalizedAsync(strs.adsarm_enable(Prefix));
+                    await ReplyConfirmLocalizedAsync(strs.adsarm_enable(Prefix));
                }
                else
                {
-                    await ReplyErrorLocalizedAsync(strs.adsarm_disable(Prefix));
+                    await ReplyConfirmLocalizedAsync(strs.adsarm_disable(Prefix));
                }
            }

--- a/src/NadekoBot/Modules/Administration/SelfCommands.cs
+++ b/src/NadekoBot/Modules/Administration/SelfCommands.cs
@@ -88,7 +88,7 @@ namespace NadekoBot.Modules.Administration
                };
                _service.AddNewAutoCommand(cmd);

-                await ReplyErrorLocalizedAsync(strs.autocmd_add(Format.Code(Format.Sanitize(cmdText)), cmd.Interval));
+                await ReplyConfirmLocalizedAsync(strs.autocmd_add(Format.Code(Format.Sanitize(cmdText)), cmd.Interval));
            }

            [NadekoCommand, Aliases]
@@ -226,7 +226,7 @@ namespace NadekoBot.Modules.Administration
                if (enabled)
                    await ReplyConfirmLocalizedAsync(strs.fwdm_start).ConfigureAwait(false);
                else
-                    await ReplyConfirmLocalizedAsync(strs.fwdm_stop).ConfigureAwait(false);
+                    await ReplyPendingLocalizedAsync(strs.fwdm_stop).ConfigureAwait(false);
            }

            [NadekoCommand, Aliases]
@@ -238,7 +238,7 @@ namespace NadekoBot.Modules.Administration
                if (enabled)
                    await ReplyConfirmLocalizedAsync(strs.fwall_start).ConfigureAwait(false);
                else
-                    await ReplyConfirmLocalizedAsync(strs.fwall_stop).ConfigureAwait(false);
+                    await ReplyPendingLocalizedAsync(strs.fwall_stop).ConfigureAwait(false);

            }

@@ -376,7 +376,7 @@ namespace NadekoBot.Modules.Administration
                var curUser = await ctx.Guild.GetCurrentUserAsync().ConfigureAwait(false);
                await curUser.ModifyAsync(u => u.Nickname = newNick).ConfigureAwait(false);

-                await ReplyErrorLocalizedAsync(strs.bot_nick(Format.Bold(newNick) ?? "-"));
+                await ReplyConfirmLocalizedAsync(strs.bot_nick(Format.Bold(newNick) ?? "-"));
            }

            [NadekoCommand, Aliases]
@@ -395,7 +395,7 @@ namespace NadekoBot.Modules.Administration
                
                await gu.ModifyAsync(u => u.Nickname = newNick).ConfigureAwait(false);

-                await ReplyErrorLocalizedAsync(strs.user_nick(Format.Bold(gu.ToString()), Format.Bold(newNick) ?? "-"));
+                await ReplyConfirmLocalizedAsync(strs.user_nick(Format.Bold(gu.ToString()), Format.Bold(newNick) ?? "-"));
            }

            [NadekoCommand, Aliases]
@@ -496,7 +496,7 @@ namespace NadekoBot.Modules.Administration
            public async Task ImagesReload()
            {
                await _service.ReloadImagesAsync();
-                await ReplyErrorLocalizedAsync(strs.images_loading);
+                await ReplyConfirmLocalizedAsync(strs.images_loading);
            }
            
            [NadekoCommand, Aliases]
--- a/src/NadekoBot/Modules/Administration/Services/LogCommandService.cs
+++ b/src/NadekoBot/Modules/Administration/Services/LogCommandService.cs
@@ -6,6 +6,8 @@ using System.Threading;
 using System.Threading.Tasks;
 using Discord;
 using Discord.WebSocket;
+using LinqToDB;
+using LinqToDB.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Caching.Memory;
 using NadekoBot.Common.Collections;
@@ -21,7 +23,7 @@ namespace NadekoBot.Modules.Administration.Services
    {
        void AddDeleteIgnore(ulong xId);
        Task LogServer(ulong guildId, ulong channelId, bool actionValue);
-        bool LogIgnore(ulong guildId, ulong channelId);
+        bool LogIgnore(ulong guildId, ulong itemId, IgnoredItemType itemType);
        LogSetting GetGuildLogSettings(ulong guildId);
        bool Log(ulong guildId, ulong? channelId, LogType type);
    }
@@ -37,7 +39,7 @@ namespace NadekoBot.Modules.Administration.Services
            return Task.CompletedTask;
        }

-        public bool LogIgnore(ulong guildId, ulong channelId)
+        public bool LogIgnore(ulong guildId, ulong itemId, IgnoredItemType itemType)
        {
            return false;
        }
@@ -97,7 +99,7 @@ namespace NadekoBot.Modules.Administration.Services
                    .AsQueryable()
                    .AsNoTracking()
                    .Where(x => guildIds.Contains(x.GuildId))
-                    .Include(ls => ls.IgnoredChannels)
+                    .Include(ls => ls.LogIgnores)
                    .ToList();

                GuildLogSettings = configs
@@ -165,21 +167,23 @@ namespace NadekoBot.Modules.Administration.Services
            _ignoreMessageIds.Add(messageId);
        }

-        public bool LogIgnore(ulong gid, ulong cid)
+        public bool LogIgnore(ulong gid, ulong itemId, IgnoredItemType itemType)
        {
            int removed = 0;
            using (var uow = _db.GetDbContext())
            {
                var logSetting = uow.LogSettingsFor(gid);
-                removed = logSetting.IgnoredChannels.RemoveWhere(ilc => ilc.ChannelId == cid);
+                removed = logSetting.LogIgnores
+                    .RemoveAll(x => x.ItemType == itemType && itemId == x.LogItemId);
+                
                if (removed == 0)
                {
-                    var toAdd = new IgnoredLogChannel {ChannelId = cid};
-                    logSetting.IgnoredChannels.Add(toAdd);
+                    var toAdd = new IgnoredLogItem { LogItemId = itemId, ItemType = itemType};
+                    logSetting.LogIgnores.Add(toAdd);
                }

-                GuildLogSettings.AddOrUpdate(gid, logSetting, (_, _) => logSetting);
                uow.SaveChanges();
+                GuildLogSettings.AddOrUpdate(gid, logSetting, (_, _) => logSetting);
            }

            return removed > 0;
@@ -580,7 +584,8 @@ namespace NadekoBot.Modules.Administration.Services
            {
                try
                {
-                    if (!GuildLogSettings.TryGetValue(before.Guild.Id, out LogSetting logSetting))
+                    if (!GuildLogSettings.TryGetValue(before.Guild.Id, out LogSetting logSetting)
+                        || logSetting.LogIgnores.Any(ilc => ilc.LogItemId == after.Id && ilc.ItemType == IgnoredItemType.User))
                        return;

                    ITextChannel logChannel;
@@ -682,7 +687,7 @@ namespace NadekoBot.Modules.Administration.Services

                    if (!GuildLogSettings.TryGetValue(before.Guild.Id, out LogSetting logSetting)
                        || (logSetting.ChannelUpdatedId is null)
-                        || logSetting.IgnoredChannels.Any(ilc => ilc.ChannelId == after.Id))
+                        || logSetting.LogIgnores.Any(ilc => ilc.LogItemId == after.Id && ilc.ItemType == IgnoredItemType.Channel))
                        return;

                    ITextChannel logChannel;
@@ -733,7 +738,7 @@ namespace NadekoBot.Modules.Administration.Services

                    if (!GuildLogSettings.TryGetValue(ch.Guild.Id, out LogSetting logSetting)
                        || (logSetting.ChannelDestroyedId is null)
-                        || logSetting.IgnoredChannels.Any(ilc => ilc.ChannelId == ch.Id))
+                        || logSetting.LogIgnores.Any(ilc => ilc.LogItemId == ch.Id && ilc.ItemType == IgnoredItemType.Channel))
                        return;

                    ITextChannel logChannel;
@@ -772,7 +777,7 @@ namespace NadekoBot.Modules.Administration.Services
                        return;

                    if (!GuildLogSettings.TryGetValue(ch.Guild.Id, out LogSetting logSetting)
-                        || (logSetting.ChannelCreatedId is null))
+                        || logSetting.ChannelCreatedId is null)
                        return;

                    ITextChannel logChannel;
@@ -817,7 +822,8 @@ namespace NadekoBot.Modules.Administration.Services
                        return;

                    if (!GuildLogSettings.TryGetValue(usr.Guild.Id, out LogSetting logSetting)
-                        || (logSetting.LogVoicePresenceId is null))
+                        || (logSetting.LogVoicePresenceId is null)
+                        || logSetting.LogIgnores.Any(ilc => ilc.LogItemId == iusr.Id && ilc.ItemType == IgnoredItemType.User))
                        return;

                    ITextChannel logChannel;
@@ -862,49 +868,6 @@ namespace NadekoBot.Modules.Administration.Services
            return Task.CompletedTask;
        }

-        //private Task _client_UserPresenceUpdated(Optional<SocketGuild> optGuild, SocketUser usr, SocketPresence before, SocketPresence after)
-        //{
-        //    var _ = Task.Run(async () =>
-        //    {
-        //        try
-        //        {
-        //            var guild = optGuild.GetValueOrDefault() ?? (usr as SocketGuildUser)?.Guild;
-
-        //            if (guild is null)
-        //                return;
-
-        //            if (!GuildLogSettings.TryGetValue(guild.Id, out LogSetting logSetting)
-        //                || (logSetting.LogUserPresenceId is null)
-        //                || before.Status == after.Status)
-        //                return;
-
-        //            ITextChannel logChannel;
-        //            if ((logChannel = await TryGetLogChannel(guild, logSetting, LogType.UserPresence)) is null)
-        //                return;
-        //            string str = "";
-        //            if (before.Status != after.Status)
-        //                str = "🎭" + Format.Code(PrettyCurrentTime(g)) +
-        //                      GetText(logChannel.Guild, strs.user_status_change(,
-        //                            "👤" + Format.Bold(usr.Username),
-        //                            Format.Bold(after.Status.ToString()));
-
-        //            //if (before.Game?.Name != after.Game?.Name)
-        //            //{
-        //            //    if (str != "")
-        //            //        str += "\n";
-        //            //    str += $"👾`{prettyCurrentTime}`👤__**{usr.Username}**__ is now playing **{after.Game?.Name}**.";
-        //            //}
-
-        //            PresenceUpdates.AddOrUpdate(logChannel, new List<string>() { str }, (id, list) => { list.Add(str); return list; });
-        //        }
-        //        catch
-        //        {
-        //            // ignored
-        //        }
-        //    });
-        //    return Task.CompletedTask;
-        //}
-
        private Task _client_UserLeft(IGuildUser usr)
        {
            var _ = Task.Run(async () =>
@@ -912,7 +875,8 @@ namespace NadekoBot.Modules.Administration.Services
                try
                {
                    if (!GuildLogSettings.TryGetValue(usr.Guild.Id, out LogSetting logSetting)
-                        || (logSetting.UserLeftId is null))
+                        || (logSetting.UserLeftId is null)
+                        || logSetting.LogIgnores.Any(ilc => ilc.LogItemId == usr.Id && ilc.ItemType == IgnoredItemType.User))
                        return;

                    ITextChannel logChannel;
@@ -987,7 +951,8 @@ namespace NadekoBot.Modules.Administration.Services
                try
                {
                    if (!GuildLogSettings.TryGetValue(guild.Id, out LogSetting logSetting)
-                        || (logSetting.UserUnbannedId is null))
+                        || (logSetting.UserUnbannedId is null)
+                        || logSetting.LogIgnores.Any(ilc => ilc.LogItemId == usr.Id && ilc.ItemType == IgnoredItemType.User))
                        return;

                    ITextChannel logChannel;
@@ -1021,7 +986,8 @@ namespace NadekoBot.Modules.Administration.Services
                try
                {
                    if (!GuildLogSettings.TryGetValue(guild.Id, out LogSetting logSetting)
-                        || (logSetting.UserBannedId is null))
+                        || (logSetting.UserBannedId is null)
+                        || logSetting.LogIgnores.Any(ilc => ilc.LogItemId == usr.Id && ilc.ItemType == IgnoredItemType.User))
                        return;

                    ITextChannel logChannel;
@@ -1069,7 +1035,7 @@ namespace NadekoBot.Modules.Administration.Services

                    if (!GuildLogSettings.TryGetValue(channel.Guild.Id, out LogSetting logSetting)
                        || (logSetting.MessageDeletedId is null)
-                        || logSetting.IgnoredChannels.Any(ilc => ilc.ChannelId == channel.Id))
+                        || logSetting.LogIgnores.Any(ilc => ilc.LogItemId == channel.Id && ilc.ItemType == IgnoredItemType.Channel))
                        return;

                    ITextChannel logChannel;
@@ -1127,7 +1093,7 @@ namespace NadekoBot.Modules.Administration.Services

                    if (!GuildLogSettings.TryGetValue(channel.Guild.Id, out LogSetting logSetting)
                        || (logSetting.MessageUpdatedId is null)
-                        || logSetting.IgnoredChannels.Any(ilc => ilc.ChannelId == channel.Id))
+                        || logSetting.LogIgnores.Any(ilc => ilc.LogItemId == channel.Id && ilc.ItemType == IgnoredItemType.Channel))
                        return;

                    ITextChannel logChannel;
--- a/src/NadekoBot/Modules/Administration/UserPunishCommands.cs
+++ b/src/NadekoBot/Modules/Administration/UserPunishCommands.cs
@@ -450,7 +450,7 @@ namespace NadekoBot.Modules.Administration
                    }
                }

-                await _mute.TimedBan(ctx.Guild, user, time.Time, ctx.User.ToString() + " | " + msg).ConfigureAwait(false);
+                await _mute.TimedBan(ctx.Guild, user, time.Time, (ctx.User.ToString() + " | " + msg).TrimTo(512)).ConfigureAwait(false);
                var toSend = _eb.Create().WithOkColor()
                    .WithTitle("⛔️ " + GetText(strs.banned_user))
                    .AddField(GetText(strs.username), user.ToString(), true)
@@ -476,7 +476,7 @@ namespace NadekoBot.Modules.Administration
                var user = await ((DiscordSocketClient)Context.Client).Rest.GetGuildUserAsync(ctx.Guild.Id, userId);
                if (user is null)
                {
-                    await ctx.Guild.AddBanAsync(userId, 7, ctx.User.ToString() + " | " + msg);
+                    await ctx.Guild.AddBanAsync(userId, 7, (ctx.User.ToString() + " | " + msg).TrimTo(512));
                    
                    await ctx.Channel.EmbedAsync(_eb.Create().WithOkColor()
                            .WithTitle("⛔️ " + GetText(strs.banned_user))
@@ -516,7 +516,7 @@ namespace NadekoBot.Modules.Administration
                    dmFailed = true;
                }

-                await ctx.Guild.AddBanAsync(user, 7, ctx.User.ToString() + " | " + msg).ConfigureAwait(false);
+                await ctx.Guild.AddBanAsync(user, 7, (ctx.User.ToString() + " | " + msg).TrimTo(512)).ConfigureAwait(false);

                var toSend = _eb.Create().WithOkColor()
                    .WithTitle("⛔️ " + GetText(strs.banned_user))
@@ -692,7 +692,7 @@ namespace NadekoBot.Modules.Administration
                    dmFailed = true;
                }

-                await ctx.Guild.AddBanAsync(user, 7, "Softban | " + ctx.User.ToString() + " | " + msg).ConfigureAwait(false);
+                await ctx.Guild.AddBanAsync(user, 7, ("Softban | " + ctx.User.ToString() + " | " + msg).TrimTo(512)).ConfigureAwait(false);
                try { await ctx.Guild.RemoveBanAsync(user).ConfigureAwait(false); }
                catch { await ctx.Guild.RemoveBanAsync(user).ConfigureAwait(false); }

@@ -749,7 +749,7 @@ namespace NadekoBot.Modules.Administration
                    dmFailed = true;
                }
            
-                await user.KickAsync(ctx.User.ToString() + " | " + msg).ConfigureAwait(false);
+                await user.KickAsync((ctx.User.ToString() + " | " + msg).TrimTo(512)).ConfigureAwait(false);
                
                var toSend = _eb.Create().WithOkColor()
                    .WithTitle(GetText(strs.kicked_user))
--- a/src/NadekoBot/Modules/CustomReactions/CustomReactions.cs
+++ b/src/NadekoBot/Modules/CustomReactions/CustomReactions.cs
@@ -149,7 +149,7 @@ namespace NadekoBot.Modules.CustomReactions
                await ctx.Channel.EmbedAsync(_eb.Create().WithOkColor()
                    .WithDescription($"#{id}")
                    .AddField(GetText(strs.trigger), found.Trigger.TrimTo(1024))
-                    .AddField(GetText(strs.response), (found.Response + "\n```css\n" + found.Response).TrimTo(1020) + "```")
+                    .AddField(GetText(strs.response), found.Response.TrimTo(1000).Replace("](", "]\\("))
                    ).ConfigureAwait(false);
            }
        }
@@ -294,7 +294,7 @@ namespace NadekoBot.Modules.CustomReactions
                .WithDescription("This will delete all custom reactions on this server.")).ConfigureAwait(false))
            {
                var count = _service.DeleteAllCustomReactions(ctx.Guild.Id);
-                await ReplyErrorLocalizedAsync(strs.cleared(count));
+                await ReplyConfirmLocalizedAsync(strs.cleared(count));
            }
        }

--- a/src/NadekoBot/Modules/Gambling/Common/GamblingConfig.cs
+++ b/src/NadekoBot/Modules/Gambling/Common/GamblingConfig.cs
@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using Cloneable;
 using NadekoBot.Common;
 using NadekoBot.Common.Yml;
+using YamlDotNet.Serialization;

 namespace NadekoBot.Modules.Gambling.Common
 {
@@ -22,7 +23,7 @@ namespace NadekoBot.Modules.Gambling.Common
        }

        [Comment(@"DO NOT CHANGE")]
-        public int Version { get; set; } = 1;
+        public int Version { get; set; } = 2;

        [Comment(@"Currency settings")]
        public CurrencyConfig Currency { get; set; }
@@ -59,6 +60,10 @@ Set 0 for unlimited")]
        [Comment(@"Amount of currency selfhosters will get PER pledged dollar CENT.
 1 = 100 currency per $. Used almost exclusively on public nadeko.")]
        public decimal PatreonCurrencyPerCent { get; set; } = 1;
+        
+        [Comment(@"Currency reward per vote.
+This will work only if you've set up VotesApi and correct credentials for topgg and/or discords voting")]
+        public long VoteReward { get; set; } = 100;
    }

    public class CurrencyConfig
@@ -179,7 +184,8 @@ default is 0.02, which is 2%")]

        public MultipliersData Multipliers { get; set; } = new MultipliersData();

-        [Comment(@"List of items available for gifting.")]
+        [Comment(@"List of items available for gifting.
+If negative is true, gift will instead reduce waifu value.")]
        public List<WaifuItemModel> Items { get; set; } = new List<WaifuItemModel>();

        public WaifuConfig()
@@ -260,6 +266,11 @@ Default 1 (meaning no effect)")]
 Default 0.95 (meaning 95%)
 Example: If a waifu is worth 1000, and she receives a gift worth 100, her new value will be 1095)")]
        public decimal GiftEffect { get; set; } = 0.95M;
+        
+        [Comment(@"What percentage of the value of the gift will a waifu lose when she's gifted a gift marked as 'negative'.
+Default 0.5 (meaning 50%)
+Example: If a waifu is worth 1000, and she receives a negative gift worth 100, her new value will be 950)")]
+        public decimal NegativeGiftEffect { get; set; } = 0.50M;
    }

    [Cloneable]
@@ -268,19 +279,24 @@ Example: If a waifu is worth 1000, and she receives a gift worth 100, her new va
        public string ItemEmoji { get; set; }
        public int Price { get; set; }
        public string Name { get; set; }
+        
+        [YamlMember(DefaultValuesHandling = DefaultValuesHandling.OmitDefaults)]
+        public bool Negative { get; set; }

        public WaifuItemModel()
        {
            
        }
        
-        public WaifuItemModel(string itemEmoji, int price, string name)
+        public WaifuItemModel(string itemEmoji, int price, string name, bool negative = false)
        {
            ItemEmoji = itemEmoji;
            Price = price;
            Name = name;
+            Negative = negative;
        }

+
        public override string ToString() => Name;
    }

--- a/src/NadekoBot/Modules/Gambling/Common/GamblingError.cs
+++ b/src/NadekoBot/Modules/Gambling/Common/GamblingError.cs
@@ -0,0 +1,8 @@
+namespace NadekoBot.Modules.Gambling
+{
+    public enum GamblingError
+    {
+        None,
+        NotEnough
+    }
+}
--- a/src/NadekoBot/Modules/Gambling/Common/Slot/SlotGame.cs
+++ b/src/NadekoBot/Modules/Gambling/Common/Slot/SlotGame.cs
@@ -0,0 +1,44 @@
+using System;
+using System.Linq;
+using NadekoBot.Common;
+
+namespace NadekoBot.Modules.Gambling.Common.Slot
+{
+    public class SlotGame
+    {
+        public class Result
+        {
+            public float Multiplier { get; }
+            public int[] Rolls { get; }
+
+            public Result(float multiplier, int[] rolls)
+            {
+                Multiplier = multiplier;
+                Rolls = rolls;
+            }
+        }
+
+        private static readonly Random _rng = new NadekoRandom();
+
+        public SlotGame()
+        {
+        }
+
+        public Result Spin()
+        {
+            var rolls = new int[] { _rng.Next(0, 6), _rng.Next(0, 6), _rng.Next(0, 6) };
+            var multi = 0;
+
+            if (rolls.All(x => x == 5))
+                multi = 30;
+            else if (rolls.All(x => x == rolls[0]))
+                multi = 10;
+            else if (rolls.Count(x => x == 5) == 2)
+                multi = 4;
+            else if (rolls.Any(x => x == 5))
+                multi = 1;
+
+            return new Result(multi, rolls);
+        }
+    }
+}
--- a/src/NadekoBot/Modules/Gambling/Common/SlotResponse.cs
+++ b/src/NadekoBot/Modules/Gambling/Common/SlotResponse.cs
@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+
+namespace NadekoBot.Modules.Gambling
+{
+    public class SlotResponse
+    {
+        public float Multiplier { get; set; }
+        public long Won { get; set; }
+        public List<int> Rolls { get; set; } = new List<int>();
+        public GamblingError Error { get; set; }
+    }
+}
--- a/src/NadekoBot/Modules/Gambling/Common/Waifu/WaifuProfileTitle.cs
+++ b/src/NadekoBot/Modules/Gambling/Common/Waifu/WaifuProfileTitle.cs
@@ -1,14 +0,0 @@
-namespace NadekoBot.Modules.Gambling.Common.Waifu
-{
-    public struct WaifuProfileTitle
-    {
-        public int Count { get; }
-        public string Title { get; }
-
-        public WaifuProfileTitle(int count, string title)
-        {
-            Count = count;
-            Title = title;
-        }
-    }
-}
--- a/src/NadekoBot/Modules/Gambling/CurrencyEventsCommands.cs
+++ b/src/NadekoBot/Modules/Gambling/CurrencyEventsCommands.cs
@@ -17,11 +17,6 @@ namespace NadekoBot.Modules.Gambling
        [Group]
        public class CurrencyEventsCommands : GamblingSubmodule<CurrencyEventsService>
        {
-            public enum OtherEvent
-            {
-                BotListUpvoters
-            }
-
            public CurrencyEventsCommands(GamblingConfigService gamblingConf) : base(gamblingConf)
            {
            }
@@ -37,41 +32,36 @@ namespace NadekoBot.Modules.Gambling
                    ctx.Channel.Id,
                    ev,
                    opts,
-                    GetEmbed
-                    ).ConfigureAwait(false))
+                    GetEmbed))
                {
                    await ReplyErrorLocalizedAsync(strs.start_event_fail).ConfigureAwait(false);
-                    return;
                }
            }

            private IEmbedBuilder GetEmbed(CurrencyEvent.Type type, EventOptions opts, long currentPot)
            {
-                switch (type)
+                return type switch
                {
-                    case CurrencyEvent.Type.Reaction:
-                        return _eb.Create()
-                            .WithOkColor()
-                            .WithTitle(GetText(strs.event_title(type.ToString())))
-                            .WithDescription(GetReactionDescription(opts.Amount, currentPot))
-                            .WithFooter(GetText(strs.event_duration_footer(opts.Hours)));
-                    case CurrencyEvent.Type.GameStatus:
-                        return _eb.Create()
-                            .WithOkColor()
-                            .WithTitle(GetText(strs.event_title(type.ToString())))
-                            .WithDescription(GetGameStatusDescription(opts.Amount, currentPot))
-                            .WithFooter(GetText(strs.event_duration_footer(opts.Hours)));
-                    default:
-                        break;
-                }
-                throw new ArgumentOutOfRangeException(nameof(type));
+                    CurrencyEvent.Type.Reaction => _eb.Create()
+                        .WithOkColor()
+                        .WithTitle(GetText(strs.event_title(type.ToString())))
+                        .WithDescription(GetReactionDescription(opts.Amount, currentPot))
+                        .WithFooter(GetText(strs.event_duration_footer(opts.Hours))),
+                    CurrencyEvent.Type.GameStatus => _eb.Create()
+                        .WithOkColor()
+                        .WithTitle(GetText(strs.event_title(type.ToString())))
+                        .WithDescription(GetGameStatusDescription(opts.Amount, currentPot))
+                        .WithFooter(GetText(strs.event_duration_footer(opts.Hours))),
+                    _ => throw new ArgumentOutOfRangeException(nameof(type))
+                };
            }

            private string GetReactionDescription(long amount, long potSize)
            {
-                string potSizeStr = Format.Bold(potSize == 0
+                var potSizeStr = Format.Bold(potSize == 0
                    ? "∞" + CurrencySign
-                    : potSize.ToString() + CurrencySign);
+                    : potSize + CurrencySign);
+                
                return GetText(strs.new_reaction_event(
                    CurrencySign,
                    Format.Bold(amount + CurrencySign),
@@ -80,9 +70,10 @@ namespace NadekoBot.Modules.Gambling

            private string GetGameStatusDescription(long amount, long potSize)
            {
-                string potSizeStr = Format.Bold(potSize == 0
+                var potSizeStr = Format.Bold(potSize == 0
                    ? "∞" + CurrencySign
-                    : potSize.ToString() + CurrencySign);
+                    : potSize + CurrencySign);
+                
                return GetText(strs.new_gamestatus_event(
                    CurrencySign,
                    Format.Bold(amount + CurrencySign),
--- a/src/NadekoBot/Modules/Gambling/FlipCoinCommands.cs
+++ b/src/NadekoBot/Modules/Gambling/FlipCoinCommands.cs
@@ -22,15 +22,12 @@ namespace NadekoBot.Modules.Gambling
        {
            private readonly IImageCache _images;
            private readonly ICurrencyService _cs;
-            private readonly DbService _db;
            private static readonly NadekoRandom rng = new NadekoRandom();

-            public FlipCoinCommands(IDataCache data, ICurrencyService cs, DbService db,
-                GamblingConfigService gss) : base(gss)
+            public FlipCoinCommands(IDataCache data, ICurrencyService cs, GamblingConfigService gss) : base(gss)
            {
                _images = data.LocalImages;
                _cs = cs;
-                _db = db;
            }

            [NadekoCommand, Aliases]
--- a/src/NadekoBot/Modules/Gambling/Gambling.cs
+++ b/src/NadekoBot/Modules/Gambling/Gambling.cs
@@ -217,7 +217,7 @@ namespace NadekoBot.Modules.Gambling
        [Priority(0)]
        public async Task Cash(ulong userId)
        {
-            await ReplyErrorLocalizedAsync(strs.has(Format.Code(userId.ToString()), $"{GetCurrency(userId)} {CurrencySign}"));
+            await ReplyConfirmLocalizedAsync(strs.has(Format.Code(userId.ToString()), $"{GetCurrency(userId)} {CurrencySign}"));
        }

        [NadekoCommand, Aliases]
@@ -269,7 +269,7 @@ namespace NadekoBot.Modules.Gambling
                $"Awarded by bot owner. ({ctx.User.Username}/{ctx.User.Id}) {(msg ?? "")}",
                amount,
                gamble: (ctx.Client.CurrentUser.Id != usrId)).ConfigureAwait(false);
-            await ReplyErrorLocalizedAsync(strs.awarded(n(amount) + CurrencySign, $"<@{usrId}>"));
+            await ReplyConfirmLocalizedAsync(strs.awarded(n(amount) + CurrencySign, $"<@{usrId}>"));
        }

        [NadekoCommand, Aliases]
@@ -340,7 +340,7 @@ namespace NadekoBot.Modules.Gambling

            if (await _cs.RemoveAsync(usrId, $"Taken by bot owner.({ctx.User.Username}/{ctx.User.Id})", amount,
                gamble: (ctx.Client.CurrentUser.Id != usrId)).ConfigureAwait(false))
-                await ReplyErrorLocalizedAsync(strs.take(amount + CurrencySign, $"<@{usrId}>"));
+                await ReplyConfirmLocalizedAsync(strs.take(amount + CurrencySign, $"<@{usrId}>"));
            else
                await ReplyErrorLocalizedAsync(strs.take_fail(amount + CurrencySign, Format.Code(usrId.ToString()), CurrencySign));
        }
--- a/src/NadekoBot/Modules/Gambling/Services/CurrencyEventsService.cs
+++ b/src/NadekoBot/Modules/Gambling/Services/CurrencyEventsService.cs
@@ -8,8 +8,6 @@ using System.Threading.Tasks;
 using System;
 using NadekoBot.Services.Database.Models;
 using System.Net.Http;
-using Newtonsoft.Json;
-using System.Linq;
 using NadekoBot.Modules.Gambling.Services;
 using Serilog;

@@ -17,76 +15,22 @@ namespace NadekoBot.Modules.Gambling.Services
 {
    public class CurrencyEventsService : INService
    {
-        public class VoteModel
-        {
-            public ulong User { get; set; }
-            public long Date { get; set; }
-        }
        private readonly DiscordSocketClient _client;
        private readonly ICurrencyService _cs;
-        private readonly IBotCredentials _creds;
-        private readonly IHttpClientFactory _http;
        private readonly GamblingConfigService _configService;
+
        private readonly ConcurrentDictionary<ulong, ICurrencyEvent> _events =
            new ConcurrentDictionary<ulong, ICurrencyEvent>();

-        public CurrencyEventsService(DiscordSocketClient client,
-            IBotCredentials creds, ICurrencyService cs,
-            IHttpClientFactory http, GamblingConfigService configService)
+
+        public CurrencyEventsService(
+            DiscordSocketClient client,
+            ICurrencyService cs,
+            GamblingConfigService configService)
        {
            _client = client;
            _cs = cs;
-            _creds = creds;
-            _http = http;
            _configService = configService;
-            
-            if (_client.ShardId == 0)
-            {
-                Task t = BotlistUpvoteLoop();
-            }
-        }
-
-        // todo future use votes api directly?
-        private async Task BotlistUpvoteLoop()
-        {
-            if (string.IsNullOrWhiteSpace(_creds.VotesUrl))
-                return;
-            
-            while (true)
-            {
-                await Task.Delay(TimeSpan.FromHours(1)).ConfigureAwait(false);
-                await TriggerVoteCheck().ConfigureAwait(false);
-            }
-        }
-
-        private async Task TriggerVoteCheck()
-        {
-            try
-            {
-                using (var req = new HttpRequestMessage(HttpMethod.Get, _creds.VotesUrl))
-                {
-                    if (!string.IsNullOrWhiteSpace(_creds.VotesToken))
-                        req.Headers.Add("Authorization", _creds.VotesToken);
-                    using (var http = _http.CreateClient())
-                    using (var res = await http.SendAsync(req).ConfigureAwait(false))
-                    {
-                        if (!res.IsSuccessStatusCode)
-                        {
-                            Log.Warning("Botlist API not reached.");
-                            return;
-                        }
-                        var resStr = await res.Content.ReadAsStringAsync().ConfigureAwait(false);
-                        var ids = JsonConvert.DeserializeObject<VoteModel[]>(resStr)
-                            .Select(x => x.User)
-                            .Distinct();
-                        await _cs.AddBulkAsync(ids, ids.Select(x => "Voted - <https://discordbots.org/bot/nadeko/vote>"), ids.Select(x => 10L), true).ConfigureAwait(false);
-                    }
-                }
-            }
-            catch (Exception ex)
-            {
-                Log.Warning(ex, "Error in TriggerVoteCheck");
-            }
        }

        public async Task<bool> TryCreateEventAsync(ulong guildId, ulong channelId, CurrencyEvent.Type type,
@@ -127,6 +71,7 @@ namespace NadekoBot.Modules.Gambling.Services
                    return false;
                }
            }
+
            return added;
        }

@@ -136,4 +81,4 @@ namespace NadekoBot.Modules.Gambling.Services
            return Task.CompletedTask;
        }
    }
-}
+}
--- a/src/NadekoBot/Modules/Gambling/Services/GamblingConfigService.cs
+++ b/src/NadekoBot/Modules/Gambling/Services/GamblingConfigService.cs
@@ -1,7 +1,11 @@
-using NadekoBot.Common;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NadekoBot.Common;
 using NadekoBot.Common.Configs;
 using NadekoBot.Modules.Gambling.Common;
 using NadekoBot.Services;
+using NadekoBot.Services.Database.Models;

 namespace NadekoBot.Modules.Gambling.Services
 {
@@ -34,9 +38,39 @@ namespace NadekoBot.Modules.Gambling.Services
            AddParsedProp("waifu.multi.divorce_value", gs => gs.Waifu.Multipliers.DivorceNewValue, decimal.TryParse, ConfigPrinters.ToString, val => val > 0);
            AddParsedProp("waifu.multi.all_gifts", gs => gs.Waifu.Multipliers.AllGiftPrices, decimal.TryParse, ConfigPrinters.ToString, val => val > 0);
            AddParsedProp("waifu.multi.gift_effect", gs => gs.Waifu.Multipliers.GiftEffect, decimal.TryParse, ConfigPrinters.ToString, val => val >= 0);
+            AddParsedProp("waifu.multi.negative_gift_effect", gs => gs.Waifu.Multipliers.NegativeGiftEffect, decimal.TryParse, ConfigPrinters.ToString, val => val >= 0);
            AddParsedProp("decay.percent", gs => gs.Decay.Percent, decimal.TryParse, ConfigPrinters.ToString, val => val >= 0 && val <= 1);
            AddParsedProp("decay.maxdecay", gs => gs.Decay.MaxDecay, int.TryParse, ConfigPrinters.ToString, val => val >= 0);
            AddParsedProp("decay.threshold", gs => gs.Decay.MinThreshold, int.TryParse, ConfigPrinters.ToString, val => val >= 0);
+
+            Migrate();
+        }
+
+        private readonly IEnumerable<WaifuItemModel> antiGiftSeed = new[]
+        {
+            new WaifuItemModel("🥀", 100, "WiltedRose", true),
+            new WaifuItemModel("✂️", 1000, "Haircut", true),
+            new WaifuItemModel("🧻", 10000, "ToiletPaper", true),
+        }; 
+        
+        public void Migrate()
+        {
+            if (_data.Version < 2)
+            {
+                ModifyConfig(c =>
+                {
+                    c.Waifu.Items = c.Waifu.Items.Concat(antiGiftSeed).ToList();
+                    c.Version = 2;
+                });
+            }
+
+            if (_data.Version < 3)
+            {
+                ModifyConfig(c =>
+                {
+                    c.VoteReward = 100;
+                });
+            }
        }
    }
 }
--- a/src/NadekoBot/Modules/Gambling/Services/GamblingService.cs
+++ b/src/NadekoBot/Modules/Gambling/Services/GamblingService.cs
@@ -6,12 +6,14 @@ using NadekoBot.Modules.Gambling.Common.WheelOfFortune;
 using Newtonsoft.Json;
 using System;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.EntityFrameworkCore;
 using NadekoBot.Common;
 using NadekoBot.Db;
+using NadekoBot.Modules.Gambling.Common.Slot;
 using NadekoBot.Modules.Gambling.Services;
 using Serilog;

@@ -82,6 +84,41 @@ WHERE CurrencyAmount > {config.Decay.MinThreshold} AND UserId!={_client.CurrentU
                }, null, TimeSpan.FromMinutes(5), TimeSpan.FromMinutes(5));
            }
        }
+        
+        public async Task<SlotResponse> SlotAsync(ulong userId, long amount)
+        {
+            var takeRes = await _cs.RemoveAsync(userId, "Slot Machine", amount, true);
+            
+            if (!takeRes)
+            {
+                return new SlotResponse
+                {
+                    Error = GamblingError.NotEnough
+                };
+            }
+
+            var game = new SlotGame();
+            var result = game.Spin();
+            long won = 0;
+
+            if (result.Multiplier > 0)
+            {
+                won = (long)(result.Multiplier * amount);
+
+                await _cs.AddAsync(userId, $"Slot Machine x{result.Multiplier}", won, true);
+            }
+
+            var toReturn = new SlotResponse
+            {
+                Multiplier = result.Multiplier,
+                Won = won,
+            };
+
+            toReturn.Rolls.AddRange(result.Rolls);
+
+            return toReturn;
+        }
+

        public struct EconomyResult
        {
--- a/src/NadekoBot/Modules/Gambling/Services/VoteRewardService.cs
+++ b/src/NadekoBot/Modules/Gambling/Services/VoteRewardService.cs
@@ -0,0 +1,122 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Threading.Tasks;
+using NadekoBot.Common.ModuleBehaviors;
+using NadekoBot.Services;
+using Discord.WebSocket;
+using Serilog;
+
+namespace NadekoBot.Modules.Gambling.Services
+{
+    public class VoteModel
+    {
+        [JsonPropertyName("userId")]
+        public ulong UserId { get; set; }
+    }
+    
+    public class VoteRewardService : INService, IReadyExecutor
+    {
+        private readonly DiscordSocketClient _client;
+        private readonly IBotCredentials _creds;
+        private readonly IHttpClientFactory _httpClientFactory;
+        private readonly ICurrencyService _currencyService;
+        private readonly GamblingConfigService _gamb;
+        private HttpClient _http;
+
+        public VoteRewardService(
+            DiscordSocketClient client,
+            IBotCredentials creds,
+            IHttpClientFactory httpClientFactory,
+            ICurrencyService currencyService,
+            GamblingConfigService gamb)
+        {
+            _client = client;
+            _creds = creds;
+            _httpClientFactory = httpClientFactory;
+            _currencyService = currencyService;
+            _gamb = gamb;
+        }
+        
+        public async Task OnReadyAsync()
+        {
+            if (_client.ShardId != 0)
+                return;
+            
+            _http = new HttpClient(new HttpClientHandler()
+            {
+                AllowAutoRedirect = false,
+                ServerCertificateCustomValidationCallback = delegate { return true; }
+            });
+            
+            while (true)
+            {
+                await Task.Delay(30000);
+
+                var topggKey = _creds.Votes?.TopggKey;
+                var topggServiceUrl = _creds.Votes?.TopggServiceUrl;
+
+                try
+                {
+                    if (!string.IsNullOrWhiteSpace(topggKey)
+                        && !string.IsNullOrWhiteSpace(topggServiceUrl))
+                    {
+                        _http.DefaultRequestHeaders.Authorization = new(topggKey);
+                        var uri = new Uri(new(topggServiceUrl), "topgg/new");
+                        var res = await _http.GetStringAsync(uri);
+                        var data = JsonSerializer.Deserialize<List<VoteModel>>(res);
+
+                        if (data is { Count: > 0 })
+                        {
+                            var ids = data.Select(x => x.UserId).ToList();
+
+                            await _currencyService.AddBulkAsync(ids,
+                                data.Select(_ => "top.gg vote reward"),
+                                data.Select(x => _gamb.Data.VoteReward),
+                                true);
+
+                            Log.Information("Rewarding {Count} top.gg voters", ids.Count());
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Log.Error(ex, "Critical error loading top.gg vote rewards.");
+                }
+
+                var discordsKey = _creds.Votes?.DiscordsKey;
+                var discordsServiceUrl = _creds.Votes?.DiscordsServiceUrl;
+                
+                try
+                {
+                    if (!string.IsNullOrWhiteSpace(discordsKey)
+                        && !string.IsNullOrWhiteSpace(discordsServiceUrl))
+                    {
+                        _http.DefaultRequestHeaders.Authorization = new(discordsKey);
+                        var res = await _http.GetStringAsync(new Uri(new(discordsServiceUrl), "discords/new"));
+                        var data = JsonSerializer.Deserialize<List<VoteModel>>(res);
+
+                        if (data is { Count: > 0 })
+                        {
+                            var ids = data.Select(x => x.UserId).ToList();
+                            
+                            await _currencyService.AddBulkAsync(ids,
+                                data.Select(_ => "discords.com vote reward"),
+                                data.Select(x => _gamb.Data.VoteReward),
+                                true);
+
+                            Log.Information("Rewarding {Count} discords.com voters", ids.Count());
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Log.Error(ex, "Critical error loading discords.com vote rewards.");
+                }
+            }
+        }
+    }
+}
--- a/src/NadekoBot/Modules/Gambling/Services/WaifuService.cs
+++ b/src/NadekoBot/Modules/Gambling/Services/WaifuService.cs
@@ -394,19 +394,28 @@ namespace NadekoBot.Modules.Gambling.Services
                    });
                }

-                w.Items.Add(new WaifuItem()
+                if (!itemObj.Negative)
                {
-                    Name = itemObj.Name.ToLowerInvariant(),
-                    ItemEmoji = itemObj.ItemEmoji,
-                });
-                
-                if (w.Claimer?.UserId == from.Id)
-                {
-                    w.Price += (int) (itemObj.Price * _gss.Data.Waifu.Multipliers.GiftEffect);
+                    w.Items.Add(new WaifuItem()
+                    {
+                        Name = itemObj.Name.ToLowerInvariant(),
+                        ItemEmoji = itemObj.ItemEmoji,
+                    });
+                    
+                    if (w.Claimer?.UserId == from.Id)
+                    {
+                        w.Price += (int)(itemObj.Price * _gss.Data.Waifu.Multipliers.GiftEffect);
+                    }
+                    else
+                    {
+                        w.Price += itemObj.Price / 2;
+                    }
                }
                else
                {
-                    w.Price += itemObj.Price / 2;
+                    w.Price -= (int)(itemObj.Price * _gss.Data.Waifu.Multipliers.NegativeGiftEffect);
+                    if (w.Price < 1)
+                        w.Price = 1;
                }

                await uow.SaveChangesAsync();
@@ -512,7 +521,7 @@ namespace NadekoBot.Modules.Gambling.Services
        {
            var conf = _gss.Data;
            return conf.Waifu.Items
-                .Select(x => new WaifuItemModel(x.ItemEmoji, (int)(x.Price * conf.Waifu.Multipliers.AllGiftPrices), x.Name))
+                .Select(x => new WaifuItemModel(x.ItemEmoji, (int)(x.Price * conf.Waifu.Multipliers.AllGiftPrices), x.Name, x.Negative))
                .ToList();
        }
    }
--- a/src/NadekoBot/Modules/Gambling/ShopCommands.cs
+++ b/src/NadekoBot/Modules/Gambling/ShopCommands.cs
@@ -225,6 +225,9 @@ namespace NadekoBot.Modules.Gambling
            [BotPerm(GuildPerm.ManageRoles)]
            public async Task ShopAdd(Role _, int price, [Leftover] IRole role)
            {
+                if (price < 1)
+                    return;
+                
                var entry = new ShopEntry()
                {
                    Name = "-",
@@ -252,8 +255,11 @@ namespace NadekoBot.Modules.Gambling
            [NadekoCommand, Aliases]
            [RequireContext(ContextType.Guild)]
            [UserPerm(GuildPerm.Administrator)]
-            public async Task ShopAdd(List _, int price, [Leftover]string name)
+            public async Task ShopAdd(List _, int price, [Leftover] string name)
            {
+                if (price < 1)
+                    return;
+
                var entry = new ShopEntry()
                {
                    Name = name.TrimTo(100),
@@ -266,13 +272,14 @@ namespace NadekoBot.Modules.Gambling
                {
                    var entries = new IndexedCollection<ShopEntry>(uow.GuildConfigsForId(ctx.Guild.Id,
                        set => set.Include(x => x.ShopEntries)
-                                  .ThenInclude(x => x.Items)).ShopEntries)
+                            .ThenInclude(x => x.Items)).ShopEntries)
                    {
                        entry
                    };
                    uow.GuildConfigsForId(ctx.Guild.Id, set => set).ShopEntries = entries;
                    uow.SaveChanges();
                }
+
                await ctx.Channel.EmbedAsync(EntryToEmbed(entry)
                    .WithTitle(GetText(strs.shop_item_add))).ConfigureAwait(false);
            }
--- a/src/NadekoBot/Modules/Gambling/SlotCommands.cs
+++ b/src/NadekoBot/Modules/Gambling/SlotCommands.cs
@@ -9,12 +9,16 @@ using System.Threading;
 using System.Threading.Tasks;
 using NadekoBot.Common;
 using NadekoBot.Common.Attributes;
+using NadekoBot.Db.Models;
 using NadekoBot.Modules.Gambling.Services;
 using NadekoBot.Modules.Gambling.Common;
 using NadekoBot.Services;
+using SixLabors.Fonts;
 using Image = SixLabors.ImageSharp.Image;
 using SixLabors.ImageSharp.Processing;
 using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.Drawing.Processing;
+using SixLabors.ImageSharp.PixelFormats;

 namespace NadekoBot.Modules.Gambling
 {
@@ -33,12 +37,16 @@ namespace NadekoBot.Modules.Gambling
            //thanks to judge for helping me with this

            private readonly IImageCache _images;
-            private readonly ICurrencyService _cs;
+            private FontProvider _fonts;
+            private readonly DbService _db;

-            public SlotCommands(IDataCache data, ICurrencyService cs, GamblingConfigService gamb) : base(gamb)
+            public SlotCommands(IDataCache data,
+                FontProvider fonts, DbService db,
+                GamblingConfigService gamb) : base(gamb)
            {
                _images = data.LocalImages;
-                _cs = cs;
+                _fonts = fonts;
+                _db = db;
            }

            public sealed class SlotMachine
@@ -140,92 +148,115 @@ namespace NadekoBot.Modules.Gambling
            [NadekoCommand, Aliases]
            public async Task Slot(ShmartNumber amount)
            {
-                if (!_runningUsers.Add(ctx.User.Id))
+               if (!_runningUsers.Add(ctx.User.Id))
                    return;
-                try
-                {
-                    if (!await CheckBetMandatory(amount).ConfigureAwait(false))
-                        return;
-                    const int maxAmount = 9999;
-                    if (amount > maxAmount)
-                    {
-                        await ReplyErrorLocalizedAsync(strs.max_bet_limit(maxAmount + CurrencySign));
-                        return;
-                    }
+               
+               try
+               {
+                   if (!await CheckBetMandatory(amount).ConfigureAwait(false))
+                       return;
+                    
+                   await ctx.Channel.TriggerTypingAsync().ConfigureAwait(false);

-                    if (!await _cs.RemoveAsync(ctx.User, "Slot Machine", amount, false, gamble: true).ConfigureAwait(false))
-                    {
-                        await ReplyErrorLocalizedAsync(strs.not_enough(CurrencySign));
-                        return;
-                    }
-                    Interlocked.Add(ref _totalBet, amount.Value);
-                    using (var bgImage = Image.Load(_images.SlotBackground))
-                    {
-                        var result = SlotMachine.Pull();
-                        int[] numbers = result.Numbers;
+                   var result = await _service.SlotAsync(ctx.User.Id, amount);

-                        for (int i = 0; i < 3; i++)
-                        {
-                            using (var randomImage = Image.Load(_images.SlotEmojis[numbers[i]]))
-                            {
-                                bgImage.Mutate(x => x.DrawImage(randomImage, new Point(95 + 142 * i, 330), new GraphicsOptions()));
-                            }
-                        }
+                   if (result.Error != GamblingError.None)
+                   {
+                       if (result.Error == GamblingError.NotEnough)
+                       {
+                           await ReplyErrorLocalizedAsync(strs.not_enough(CurrencySign));
+                       }

-                        var won = amount * result.Multiplier;
-                        var printWon = won;
-                        var n = 0;
-                        do
-                        {
-                            var digit = (int)(printWon % 10);
-                            using (var img = Image.Load(_images.SlotNumbers[digit]))
-                            {
-                                bgImage.Mutate(x => x.DrawImage(img, new Point(230 - n * 16, 462), new GraphicsOptions()));
-                            }
-                            n++;
-                        } while ((printWon /= 10) != 0);
+                       return;
+                   }

-                        var printAmount = amount;
-                        n = 0;
-                        do
-                        {
-                            var digit = (int)(printAmount % 10);
-                            using (var img = Image.Load(_images.SlotNumbers[digit]))
-                            {
-                                bgImage.Mutate(x => x.DrawImage(img, new Point(395 - n * 16, 462), new GraphicsOptions()));
-                            }
-                            n++;
-                        } while ((printAmount /= 10) != 0);
+                   Interlocked.Add(ref _totalBet, amount);
+                   Interlocked.Add(ref _totalPaidOut, result.Won);

-                        var msg = GetText(strs.better_luck);
-                        if (result.Multiplier != 0)
-                        {
-                            await _cs.AddAsync(ctx.User, $"Slot Machine x{result.Multiplier}", amount * result.Multiplier, false, gamble: true).ConfigureAwait(false);
-                            Interlocked.Add(ref _totalPaidOut, amount * result.Multiplier);
-                            if (result.Multiplier == 1)
-                                msg = GetText(strs.slot_single(CurrencySign, 1));
-                            else if (result.Multiplier == 4)
-                                msg = GetText(strs.slot_two(CurrencySign, 4));
-                            else if (result.Multiplier == 10)
-                                msg = GetText(strs.slot_three(10));
-                            else if (result.Multiplier == 30)
-                                msg = GetText(strs.slot_jackpot(30));
-                        }
+                   long ownedAmount;
+                   using (var uow = _db.GetDbContext())
+                   {
+                       ownedAmount = uow.Set<DiscordUser>()
+                           .FirstOrDefault(x => x.UserId == ctx.User.Id)
+                           ?.CurrencyAmount ?? 0;
+                   }

-                        using (var imgStream = bgImage.ToStream())
-                        {
-                            await ctx.Channel.SendFileAsync(imgStream, "result.png", ctx.User.Mention + " " + msg + $"\n`{GetText(strs.slot_bet)}:`{amount} `{GetText(strs.won)}:` {amount * result.Multiplier}{CurrencySign}").ConfigureAwait(false);
-                        }
-                    }
-                }
-                finally
-                {
-                    var _ = Task.Run(async () =>
-                    {
-                        await Task.Delay(1000).ConfigureAwait(false);
-                        _runningUsers.Remove(ctx.User.Id);
-                    });
-                }
+                   using (var bgImage = Image.Load<Rgba32>(_images.SlotBackground, out var format))
+                   {
+                       var numbers = new int[3];
+                       result.Rolls.CopyTo(numbers, 0);
+
+                       bgImage.Mutate(x => x.DrawText(new TextGraphicsOptions
+                           {
+                               TextOptions = new TextOptions()
+                               {
+                                   HorizontalAlignment = HorizontalAlignment.Center,
+                                   VerticalAlignment = VerticalAlignment.Center,
+                                   WrapTextWidth = 140,
+                               }
+                           }, result.Won.ToString(), _fonts.DottyFont.CreateFont(65), SixLabors.ImageSharp.Color.Red,
+                           new PointF(227, 92)));
+
+                       bgImage.Mutate(x => x.DrawText(new TextGraphicsOptions
+                           {
+                               TextOptions = new TextOptions()
+                               {
+                                   HorizontalAlignment = HorizontalAlignment.Center,
+                                   VerticalAlignment = VerticalAlignment.Center,
+                                   WrapTextWidth = 135,
+                               }
+                           }, amount.ToString(), _fonts.DottyFont.CreateFont(50), SixLabors.ImageSharp.Color.Red,
+                           new PointF(129, 472)));
+
+                       bgImage.Mutate(x => x.DrawText(new TextGraphicsOptions
+                           {
+                               TextOptions = new TextOptions()
+                               {
+                                   HorizontalAlignment = HorizontalAlignment.Center,
+                                   VerticalAlignment = VerticalAlignment.Center,
+                                   WrapTextWidth = 135,
+                               }
+                           }, ownedAmount.ToString(), _fonts.DottyFont.CreateFont(50), SixLabors.ImageSharp.Color.Red,
+                           new PointF(325, 472)));
+                       //sw.PrintLap("drew red text");
+
+                       for (var i = 0; i < 3; i++)
+                       {
+                           using (var img = Image.Load(_images.SlotEmojis[numbers[i]]))
+                           {
+                               bgImage.Mutate(x => x.DrawImage(img, new Point(148 + 105 * i, 217), 1f));
+                           }
+                       }
+
+                       var msg = GetText(strs.better_luck);
+                       if (result.Multiplier > 0)
+                       {
+                           if (result.Multiplier == 1f)
+                               msg = GetText(strs.slot_single(CurrencySign, 1));
+                           else if (result.Multiplier == 4f)
+                               msg = GetText(strs.slot_two(CurrencySign, 4));
+                           else if (result.Multiplier == 10f)
+                               msg = GetText(strs.slot_three(10));
+                           else if (result.Multiplier == 30f)
+                               msg = GetText(strs.slot_jackpot(30));
+                       }
+
+                       using (var imgStream = bgImage.ToStream())
+                       {
+                           await ctx.Channel.SendFileAsync(imgStream,
+                               filename: "result.png",
+                               text: Format.Bold(ctx.User.ToString()) + " " + msg).ConfigureAwait(false);
+                       }
+                   }
+               }
+               finally
+               {
+                   var _ = Task.Run(async () =>
+                   {
+                       await Task.Delay(1000).ConfigureAwait(false);
+                       _runningUsers.Remove(ctx.User.Id);
+                   });
+               }
            }
        }
    }
--- a/src/NadekoBot/Modules/Gambling/WaifuClaimCommands.cs
+++ b/src/NadekoBot/Modules/Gambling/WaifuClaimCommands.cs
@@ -145,11 +145,11 @@ namespace NadekoBot.Modules.Gambling

                if (result == DivorceResult.SucessWithPenalty)
                {
-                    await ReplyErrorLocalizedAsync(strs.waifu_divorced_like(Format.Bold(w.Waifu.ToString()), amount + CurrencySign));
+                    await ReplyConfirmLocalizedAsync(strs.waifu_divorced_like(Format.Bold(w.Waifu.ToString()), amount + CurrencySign));
                }
                else if (result == DivorceResult.Success)
                {
-                    await ReplyErrorLocalizedAsync(strs.waifu_divorced_notlike(amount + CurrencySign));
+                    await ReplyConfirmLocalizedAsync(strs.waifu_divorced_notlike(amount + CurrencySign));
                }
                else if (result == DivorceResult.NotYourWife)
                {
@@ -306,7 +306,7 @@ namespace NadekoBot.Modules.Gambling
            [Priority(1)]
            public async Task WaifuGift(int page = 1)
            {
-                if (--page < 0 || page > 3)
+                if (--page < 0 || page > (_config.Waifu.Items.Count - 1) / 9)
                    return;

                var waifuItems = _service.GetWaifuItems();
@@ -317,10 +317,14 @@ namespace NadekoBot.Modules.Gambling
                        .WithOkColor();

                    waifuItems
-                        .OrderBy(x => x.Price)
+                        .OrderBy(x => x.Negative)
+                        .ThenBy(x => x.Price)
                        .Skip(9 * cur)
                        .Take(9)
-                        .ForEach(x => embed.AddField($"{x.ItemEmoji} {x.Name}", x.Price, true));
+                        .ForEach(x => embed
+                            .AddField($"{(!x.Negative ? string.Empty : "\\💔")} {x.ItemEmoji} {x.Name}",
+                                Format.Bold(x.Price.ToString()) + _config.Currency.Sign,
+                                true));

                    return embed;
                }, waifuItems.Count, 9);
--- a/src/NadekoBot/Modules/Games/Common/Hangman/DefaultHangmanSource.cs
+++ b/src/NadekoBot/Modules/Games/Common/Hangman/DefaultHangmanSource.cs
@@ -0,0 +1,72 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Linq;
+using NadekoBot.Common;
+using NadekoBot.Common.Yml;
+using Serilog;
+
+namespace NadekoBot.Modules.Games.Hangman
+{
+    public sealed class DefaultHangmanSource : IHangmanSource
+    {
+        private IReadOnlyDictionary<string, HangmanTerm[]> _terms = new Dictionary<string, HangmanTerm[]>();
+        private readonly Random _rng;
+
+        public DefaultHangmanSource()
+        {
+            _rng = new NadekoRandom();
+            Reload();
+        }
+
+        public void Reload()
+        {
+            if (!Directory.Exists("data/hangman"))
+            {
+                Log.Error("Hangman game won't work. Folder 'data/hangman' is missing.");
+                return;
+            }
+
+            var qs = new Dictionary<string, HangmanTerm[]>();
+            foreach (var file in Directory.EnumerateFiles("data/hangman/", "*.yml"))
+            {
+                try
+                {
+                    var data = Yaml.Deserializer.Deserialize<HangmanTerm[]>(File.ReadAllText(file));
+                    qs[Path.GetFileNameWithoutExtension(file).ToLowerInvariant()] = data;
+                }
+                catch (Exception ex)
+                {
+                    Log.Error(ex, "Loading {HangmanFile} failed.", file);
+                }
+            }
+
+            _terms = qs;
+            
+            Log.Information("Loaded {HangmanCategoryCount} hangman categories.", qs.Count);
+        }
+
+        public IReadOnlyCollection<string> GetCategories() 
+            => _terms.Keys.ToList();
+
+        public bool GetTerm(string? category, [NotNullWhen(true)] out HangmanTerm? term)
+        {
+            if (category is null)
+            {
+                var cats = GetCategories();
+                category = cats.ElementAt(_rng.Next(0, cats.Count));
+            }
+
+            if (_terms.TryGetValue(category, out var terms))
+            {
+                term = terms[_rng.Next(0, terms.Length)];
+                return true;
+            }
+
+            term = null;
+            return false;
+        }
+    }
+}
--- a/src/NadekoBot/Modules/Games/Common/Hangman/Exceptions/TermNotFoundException.cs
+++ b/src/NadekoBot/Modules/Games/Common/Hangman/Exceptions/TermNotFoundException.cs
@@ -1,19 +0,0 @@
-using System;
-
-namespace NadekoBot.Modules.Games.Common.Hangman.Exceptions
-{
-    public class TermNotFoundException : Exception
-    {
-        public TermNotFoundException() : base("Term of that type couldn't be found")
-        {
-        }
-
-        public TermNotFoundException(string message) : base(message)
-        {
-        }
-
-        public TermNotFoundException(string message, Exception innerException) : base(message, innerException)
-        {
-        }
-    }
-}
--- a/src/NadekoBot/Modules/Games/Common/Hangman/Hangman.cs
+++ b/src/NadekoBot/Modules/Games/Common/Hangman/Hangman.cs
@@ -1,170 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using NadekoBot.Extensions;
-
-namespace NadekoBot.Modules.Games.Common.Hangman
-{
-    public sealed class Hangman : IDisposable
-    {
-        public string TermType { get; }
-        public TermPool TermPool { get; }
-        public HangmanObject Term { get; }
-
-        public string ScrambledWord => "`" + String.Concat(Term.Word.Select(c =>
-        {
-            if (c == ' ')
-                return " \u2000";
-            if (!(char.IsLetter(c) || char.IsDigit(c)))
-                return $" {c}";
-
-            c = char.ToLowerInvariant(c);
-            return _previousGuesses.Contains(c) ? $" {c}" : " ◯";
-        })) + "`";
-
-        private Phase _currentPhase = Phase.Active;
-        public Phase CurrentPhase
-        {
-            get => _currentPhase;
-            set
-            {
-                if (value == Phase.Ended)
-                    _endingCompletionSource.TrySetResult(true);
-
-                _currentPhase = value;
-            }
-        }
-
-        private readonly SemaphoreSlim _locker = new SemaphoreSlim(1, 1);
-
-        private readonly HashSet<ulong> _recentUsers = new HashSet<ulong>();
-
-        public uint Errors { get; private set; } = 0;
-        public uint MaxErrors { get; } = 6;
-
-        public event Func<Hangman, string, ulong, Task> OnGameEnded = delegate { return Task.CompletedTask; };
-        public event Func<Hangman, string, char, Task> OnLetterAlreadyUsed = delegate { return Task.CompletedTask; };
-        public event Func<Hangman, string, char, Task> OnGuessFailed = delegate { return Task.CompletedTask; };
-        public event Func<Hangman, string, char, Task> OnGuessSucceeded = delegate { return Task.CompletedTask; };
-
-        private readonly HashSet<char> _previousGuesses = new HashSet<char>();
-        public ImmutableArray<char> PreviousGuesses => _previousGuesses.ToImmutableArray();
-
-        private readonly TaskCompletionSource<bool> _endingCompletionSource = new TaskCompletionSource<bool>();
-
-        public Task EndedTask => _endingCompletionSource.Task;
-
-        public Hangman(string type, TermPool tp = null)
-        {
-            this.TermType = type.Trim().ToLowerInvariant().ToTitleCase();
-            this.TermPool = tp ?? new TermPool();
-            this.Term = this.TermPool.GetTerm(type);
-        }
-
-        private void AddError()
-        {
-            if (++Errors > MaxErrors)
-            {
-                var _ = OnGameEnded(this, null, 0);
-                CurrentPhase = Phase.Ended;
-            }
-        }
-
-        public string GetHangman() => $@". ┌─────┐
-.┃...............┋
-.┃...............┋
-.┃{(Errors > 0 ? ".............😲" : "")}
-.┃{(Errors > 1 ? "............./" : "")} {(Errors > 2 ? "|" : "")} {(Errors > 3 ? "\\" : "")}
-.┃{(Errors > 4 ? "............../" : "")} {(Errors > 5 ? "\\" : "")}
-/-\";
-
-        public async Task Input(ulong userId, string userName, string input)
-        {
-            if (CurrentPhase == Phase.Ended)
-                return;
-
-            if (string.IsNullOrWhiteSpace(input))
-                return;
-
-            input = input.Trim().ToLowerInvariant();
-
-            await _locker.WaitAsync().ConfigureAwait(false);
-            try
-            {
-                if (CurrentPhase == Phase.Ended)
-                    return;
-
-                if (input.Length > 1) // tried to guess the whole word
-                {
-                    if (input != Term.Word) // failed
-                        return;
-
-                    var _ = OnGameEnded?.Invoke(this, userName, userId);
-                    CurrentPhase = Phase.Ended;
-                    return;
-                }
-
-                var ch = input[0];
-
-                if (!char.IsLetterOrDigit(ch))
-                    return;
-
-                if (!_recentUsers.Add(userId)) // don't let a single user spam guesses
-                    return;
-
-                if (!_previousGuesses.Add(ch)) // that letter was already guessed
-                {
-                    var _ = OnLetterAlreadyUsed?.Invoke(this, userName, ch);
-                }
-                else if (!Term.Word.Contains(ch)) // guessed letter doesn't exist
-                {
-                    var _ = OnGuessFailed?.Invoke(this, userName, ch);
-                    AddError();
-                }
-                else if (Term.Word.All(x => _previousGuesses.IsSupersetOf(Term.Word.ToLowerInvariant()
-                                                                            .Where(char.IsLetterOrDigit))))
-                {
-                    var _ = OnGameEnded.Invoke(this, userName, userId); // if all letters are guessed
-                    CurrentPhase = Phase.Ended;
-                }
-                else // guessed but not last letter
-                {
-                    var _ = OnGuessSucceeded?.Invoke(this, userName, ch);
-                    _recentUsers.Remove(userId); // he can guess again right away
-                    return;
-                }
-
-                var clearSpam = Task.Run(async () =>
-                {
-                    await Task.Delay(3000).ConfigureAwait(false); // remove the user from the spamlist after 5 seconds
-                    _recentUsers.Remove(userId);
-                });
-            }
-            finally { _locker.Release(); }
-        }
-
-        public async Task Stop()
-        {
-            await _locker.WaitAsync().ConfigureAwait(false);
-            try
-            {
-                CurrentPhase = Phase.Ended;
-            }
-            finally { _locker.Release(); }
-        }
-
-        public void Dispose()
-        {
-            OnGameEnded = null;
-            OnGuessFailed = null;
-            OnGuessSucceeded = null;
-            OnLetterAlreadyUsed = null;
-            _previousGuesses.Clear();
-            _recentUsers.Clear();
-            // _locker.Dispose();
-        }
-    }
-}
--- a/src/NadekoBot/Modules/Games/Common/Hangman/HangmanGame.cs
+++ b/src/NadekoBot/Modules/Games/Common/Hangman/HangmanGame.cs
@@ -0,0 +1,121 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using AngleSharp.Text;
+
+namespace NadekoBot.Modules.Games.Hangman
+{
+    public sealed class HangmanGame
+    {
+        public enum Phase { Running, Ended }
+        public enum GuessResult { NoAction, AlreadyTried, Incorrect, Guess, Win }
+
+        public record State(
+            int Errors,
+            Phase Phase,
+            string Word,
+            GuessResult GuessResult,
+            List<char> missedLetters,
+            string ImageUrl)
+        {
+            public bool Failed => Errors > 5;
+        }
+
+        private Phase CurrentPhase { get; set; }
+        
+        private readonly HashSet<char> _incorrect = new();
+        private readonly HashSet<char> _correct = new();
+        private readonly HashSet<char> _remaining = new();
+
+        private readonly string _word;
+        private readonly string _imageUrl;
+
+        public HangmanGame(HangmanTerm term)
+        {
+            _word = term.Word;
+            _imageUrl = term.ImageUrl;
+            
+            _remaining = _word
+                .ToLowerInvariant()
+                .Where(x => x.IsLetter())
+                .Select(char.ToLowerInvariant)
+                .ToHashSet();
+        }
+
+        public State GetState(GuessResult guessResult = GuessResult.NoAction)
+            => new State(_incorrect.Count,
+                CurrentPhase,
+                CurrentPhase == Phase.Ended
+                    ? _word
+                    : GetScrambledWord(),
+                guessResult,
+                _incorrect.ToList(),
+                CurrentPhase == Phase.Ended
+                    ? _imageUrl
+                    : string.Empty);
+
+        private string GetScrambledWord()
+        {
+            Span<char> output = stackalloc char[_word.Length * 2];
+            for (var i = 0; i < _word.Length; i++)
+            {
+                var ch = _word[i];
+                if (ch == ' ')
+                    output[i*2] = ' ';
+                if (!ch.IsLetter() || !_remaining.Contains(char.ToLowerInvariant(ch)))
+                    output[i*2] = ch;
+                else
+                    output[i*2] = '_';
+
+                output[i * 2 + 1] = ' ';
+            }
+
+            return new(output);
+        }
+
+        public State Guess(string guess)
+        {
+            if (CurrentPhase != Phase.Running)
+                return GetState(GuessResult.NoAction);
+
+            guess = guess.Trim();
+            if (guess.Length > 1)
+            {
+                if (guess.Equals(_word, StringComparison.InvariantCultureIgnoreCase))
+                {
+                    CurrentPhase = Phase.Ended;
+                    return GetState(GuessResult.Win);
+                }
+
+                return GetState(GuessResult.NoAction);
+            }
+
+            var charGuess = guess[0];
+            if (!char.IsLetter(charGuess))
+                return GetState(GuessResult.NoAction);
+
+            if (_incorrect.Contains(charGuess) || _correct.Contains(charGuess))
+                return GetState(GuessResult.AlreadyTried);
+
+            if (_remaining.Remove(charGuess))
+            {
+                if (_remaining.Count == 0)
+                {
+                    CurrentPhase = Phase.Ended;
+                    return GetState(GuessResult.Win);
+                }
+
+                return GetState(GuessResult.Guess);
+            }
+
+            _incorrect.Add(charGuess);
+            if (_incorrect.Count > 5)
+            {
+                CurrentPhase = Phase.Ended;
+                return GetState(GuessResult.Incorrect);
+            }
+
+            return GetState(GuessResult.Incorrect);
+        }
+    }
+}
--- a/src/NadekoBot/Modules/Games/Common/Hangman/HangmanObject.cs
+++ b/src/NadekoBot/Modules/Games/Common/Hangman/HangmanObject.cs
@@ -1,17 +0,0 @@
-using NadekoBot.Extensions;
-
-namespace NadekoBot.Modules.Games.Common.Hangman
-{
-    public class HangmanObject
-    {
-        public string Word { get; set; }
-        public string ImageUrl { get; set; }
-
-        public string GetWord()
-        {
-            var term = Word.ToTitleCase();
-
-            return $"[{term}](https://en.wikipedia.org/wiki/{term.Replace(' ', '_')})";
-        }
-    }
-}
--- a/src/NadekoBot/Modules/Games/Common/Hangman/HangmanService.cs
+++ b/src/NadekoBot/Modules/Games/Common/Hangman/HangmanService.cs
@@ -0,0 +1,147 @@
+#nullable enable
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
+using Discord;
+using Microsoft.Extensions.Caching.Memory;
+using NadekoBot.Common.ModuleBehaviors;
+using NadekoBot.Extensions;
+using NadekoBot.Modules.Games.Services;
+using NadekoBot.Services;
+
+namespace NadekoBot.Modules.Games.Hangman
+{
+    public sealed class HangmanService : IHangmanService, ILateExecutor
+    {
+        private readonly ConcurrentDictionary<ulong, HangmanGame> _hangmanGames = new();
+        private readonly IHangmanSource _source;
+        private readonly IEmbedBuilderService _eb;
+        private readonly GamesConfigService _gcs;
+        private readonly ICurrencyService _cs;
+        private readonly IMemoryCache _cdCache;
+        private readonly object _locker = new();
+
+        public HangmanService(IHangmanSource source, IEmbedBuilderService eb, GamesConfigService gcs,
+            ICurrencyService cs, IMemoryCache cdCache)
+        {
+            _source = source;
+            _eb = eb;
+            _gcs = gcs;
+            _cs = cs;
+            _cdCache = cdCache;
+        }
+
+        public bool StartHangman(
+            ulong channelId,
+            string? category,
+            [NotNullWhen(true)] out HangmanGame.State? state)
+        {
+            state = null;
+            if (!_source.GetTerm(category, out var term))
+                return false;
+
+
+            var game = new HangmanGame(term);
+            lock (_locker)
+            {
+                var hc = _hangmanGames.GetOrAdd(channelId, game);
+                if (hc == game)
+                {
+                    state = hc.GetState();
+                    return true;
+                }
+
+                return false;
+            }
+        }
+
+        public ValueTask<bool> StopHangman(ulong channelId)
+        {
+            lock (_locker)
+            {
+                if (_hangmanGames.TryRemove(channelId, out var game))
+                {
+                    return new(true);
+                }
+            }
+
+            return new(false);
+        }
+
+        public IReadOnlyCollection<string> GetHangmanTypes()
+            => _source.GetCategories();
+
+        public async Task LateExecute(IGuild guild, IUserMessage msg)
+        {
+            if (_hangmanGames.ContainsKey(msg.Channel.Id))
+            {
+                if (string.IsNullOrWhiteSpace(msg.Content))
+                    return;
+
+                if (_cdCache.TryGetValue(msg.Author.Id, out _))
+                    return;
+                
+                HangmanGame.State state;
+                long rew = 0;
+                lock (_locker)
+                {
+                    if (!_hangmanGames.TryGetValue(msg.Channel.Id, out var game))
+                        return;
+
+                    state = game.Guess(msg.Content.ToLowerInvariant());
+
+                    if (state.GuessResult == HangmanGame.GuessResult.NoAction)
+                        return;
+
+                    if (state.GuessResult == HangmanGame.GuessResult.Incorrect
+                        || state.GuessResult == HangmanGame.GuessResult.AlreadyTried)
+                    {
+                        _cdCache.Set(msg.Author.Id, string.Empty, new MemoryCacheEntryOptions()
+                        {
+                            AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(3)
+                        });
+                    }
+                    
+                    if (state.Phase == HangmanGame.Phase.Ended)
+                        if (_hangmanGames.TryRemove(msg.Channel.Id, out _))
+                            rew = _gcs.Data.Hangman.CurrencyReward;
+                }
+
+                if (rew > 0)
+                    await _cs.AddAsync(msg.Author, "hangman win", rew, gamble: true);
+
+                await SendState((ITextChannel)msg.Channel, msg.Author, msg.Content, state);
+            }
+        }
+        
+        private Task<IUserMessage> SendState(ITextChannel channel, IUser user, string content, HangmanGame.State state)
+        {
+            var embed = Games.HangmanCommands.GetEmbed(_eb, state);
+            if (state.GuessResult == HangmanGame.GuessResult.Guess)
+                embed.WithDescription($"{user} guessed the letter {content}!")
+                    .WithOkColor();
+            else if (state.GuessResult == HangmanGame.GuessResult.Incorrect && state.Failed)
+                embed.WithDescription($"{user} Letter {content} doesn't exist! Game over!")
+                    .WithErrorColor();
+            else if (state.GuessResult == HangmanGame.GuessResult.Incorrect)
+                embed.WithDescription($"{user} Letter {content} doesn't exist!")
+                    .WithErrorColor();
+            else if (state.GuessResult == HangmanGame.GuessResult.AlreadyTried)
+                embed.WithDescription($"{user} Letter {content} has already been used.")
+                    .WithPendingColor();
+            else if (state.GuessResult == HangmanGame.GuessResult.Win)
+                embed.WithDescription($"{user} won!")
+                    .WithOkColor();
+
+            if (!string.IsNullOrWhiteSpace(state.ImageUrl)
+                && Uri.IsWellFormedUriString(state.ImageUrl, UriKind.Absolute))
+            {
+                embed.WithImageUrl(state.ImageUrl);
+            }
+
+            return channel.EmbedAsync(embed);
+        }
+    }
+}
--- a/src/NadekoBot/Modules/Games/Common/Hangman/HangmanTerm.cs
+++ b/src/NadekoBot/Modules/Games/Common/Hangman/HangmanTerm.cs
@@ -0,0 +1,8 @@
+namespace NadekoBot.Modules.Games.Hangman
+{
+    public sealed class HangmanTerm
+    {
+        public string Word { get; set; }
+        public string ImageUrl { get; set; }
+    }
+}
--- a/src/NadekoBot/Modules/Games/Common/Hangman/IHangmanService.cs
+++ b/src/NadekoBot/Modules/Games/Common/Hangman/IHangmanService.cs
@@ -0,0 +1,14 @@
+#nullable enable
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
+
+namespace NadekoBot.Modules.Games.Hangman
+{
+    public interface IHangmanService
+    {
+        bool StartHangman(ulong channelId, string? category, [NotNullWhen(true)] out HangmanGame.State? hangmanController);
+        ValueTask<bool> StopHangman(ulong channelId);
+        IReadOnlyCollection<string> GetHangmanTypes();
+    }
+}
--- a/src/NadekoBot/Modules/Games/Common/Hangman/IHangmanSource.cs
+++ b/src/NadekoBot/Modules/Games/Common/Hangman/IHangmanSource.cs
@@ -0,0 +1,14 @@
+#nullable enable
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using NadekoBot.Services;
+
+namespace NadekoBot.Modules.Games.Hangman
+{
+    public interface IHangmanSource : INService
+    {
+        public IReadOnlyCollection<string> GetCategories();
+        public void Reload();
+        public bool GetTerm(string? category, [NotNullWhen(true)] out HangmanTerm? term);
+    }
+}
--- a/src/NadekoBot/Modules/Games/Common/Hangman/Phase.cs
+++ b/src/NadekoBot/Modules/Games/Common/Hangman/Phase.cs
@@ -1,8 +0,0 @@
-namespace NadekoBot.Modules.Games.Common.Hangman
-{
-    public enum Phase
-    {
-        Active,
-        Ended,
-    }
-}
--- a/src/NadekoBot/Modules/Games/Common/Hangman/TermPool.cs
+++ b/src/NadekoBot/Modules/Games/Common/Hangman/TermPool.cs
@@ -1,50 +0,0 @@
-using NadekoBot.Common;
-using NadekoBot.Modules.Games.Common.Hangman.Exceptions;
-using Newtonsoft.Json;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using Serilog;
-
-namespace NadekoBot.Modules.Games.Common.Hangman
-{
-    public class TermPool
-    {
-        const string termsPath = "data/hangman.json";
-
-        public IReadOnlyDictionary<string, HangmanObject[]> Data { get; } = new Dictionary<string, HangmanObject[]>();
-        public TermPool()
-        {
-            try
-            {
-                Data = JsonConvert.DeserializeObject<Dictionary<string, HangmanObject[]>>(File.ReadAllText(termsPath));
-                Data = Data.ToDictionary(
-                    x => x.Key.ToLowerInvariant(),
-                    x => x.Value);
-            }
-            catch (Exception ex)
-            {
-                Log.Warning(ex, "Error loading Hangman Term pool");
-            }
-        }
-
-        public HangmanObject GetTerm(string type)
-        {
-            type = type?.Trim().ToLowerInvariant();
-            var rng = new NadekoRandom();
-
-            if (type == "random")
-            {
-                type = Data.Keys.ToArray()[rng.Next(0, Data.Keys.Count())];
-            }
-            if (!Data.TryGetValue(type, out var termTypes) || termTypes.Length == 0)
-                throw new TermNotFoundException();
-
-            var obj = termTypes[rng.Next(0, termTypes.Length)];
-
-            obj.Word = obj.Word.Trim().ToLowerInvariant();
-            return obj;
-        }
-    }
-}
--- a/src/NadekoBot/Modules/Games/Common/Hangman/TermType.cs
+++ b/src/NadekoBot/Modules/Games/Common/Hangman/TermType.cs
@@ -1,14 +0,0 @@
-using System;
-
-namespace NadekoBot.Modules.Games.Common.Hangman
-{
-    [Flags]
-    public enum TermTypes
-    {
-        Countries = 0,
-        Movies = 1,
-        Animals = 2,
-        Things = 4,
-        Random = 8,
-    }
-}
--- a/src/NadekoBot/Modules/Games/HangmanCommands.cs
+++ b/src/NadekoBot/Modules/Games/HangmanCommands.cs
@@ -1,13 +1,10 @@
+#nullable enable
 using Discord.Commands;
-using NadekoBot.Extensions;
-using System;
 using System.Threading.Tasks;
 using Discord;
-using Discord.WebSocket;
 using NadekoBot.Common.Attributes;
-using NadekoBot.Modules.Games.Common.Hangman;
-using NadekoBot.Modules.Games.Services;
-using NadekoBot.Modules.Games.Common.Hangman.Exceptions;
+using NadekoBot.Extensions;
+using NadekoBot.Modules.Games.Hangman;
 using NadekoBot.Services;

 namespace NadekoBot.Modules.Games
@@ -15,136 +12,74 @@ namespace NadekoBot.Modules.Games
    public partial class Games
    {
        [Group]
-        public class HangmanCommands : NadekoSubmodule<GamesService>
+        public class HangmanCommands : NadekoSubmodule<IHangmanService>
        {
-            private readonly DiscordSocketClient _client;
-            private readonly ICurrencyService _cs;
-            private readonly GamesConfigService _gcs;
-
-            public HangmanCommands(DiscordSocketClient client, ICurrencyService cs, GamesConfigService gcs)
-            {
-                _client = client;
-                _cs = cs;
-                _gcs = gcs;
-            }
-
            [NadekoCommand, Aliases]
            [RequireContext(ContextType.Guild)]
            public async Task Hangmanlist()
            {
-                await SendConfirmAsync(Format.Code(GetText(strs.hangman_types(Prefix)) + "\n" + string.Join("\n", _service.TermPool.Data.Keys)));
+                await SendConfirmAsync(
+                    GetText(strs.hangman_types(Prefix)),
+                    _service.GetHangmanTypes().JoinWith('\n'));
+            }
+
+            private static string Draw(HangmanGame.State state)
+            {
+                return $@". ┌─────┐
+.┃...............┋
+.┃...............┋
+.┃{(state.Errors > 0 ? ".............😲" : "")}
+.┃{(state.Errors > 1 ? "............./" : "")} {(state.Errors > 2 ? "|" : "")} {(state.Errors > 3 ? "\\" : "")}
+.┃{(state.Errors > 4 ? "............../" : "")} {(state.Errors > 5 ? "\\" : "")}
+/-\";
+            }
+
+            public static IEmbedBuilder GetEmbed(IEmbedBuilderService eb, HangmanGame.State state)
+            {
+                if (state.Phase == HangmanGame.Phase.Running)
+                    return eb.Create()
+                        .WithOkColor()
+                        .AddField("Hangman", Draw(state))
+                        .AddField("Guess", Format.Code(state.Word))
+                        .WithFooter(state.missedLetters.JoinWith(' '));
+                
+                if (state.Phase == HangmanGame.Phase.Ended && state.Failed)
+                    return eb.Create()
+                        .WithErrorColor()
+                        .AddField("Hangman", Draw(state))
+                        .AddField("Guess", Format.Code(state.Word))
+                        .WithFooter(state.missedLetters.JoinWith(' '));
+                else
+                {
+                    return eb.Create()
+                        .WithOkColor()
+                        .AddField("Hangman", Draw(state))
+                        .AddField("Guess", Format.Code(state.Word))
+                        .WithFooter(state.missedLetters.JoinWith(' '));
+                }
            }

            [NadekoCommand, Aliases]
            [RequireContext(ContextType.Guild)]
-            public async Task Hangman([Leftover]string type = "random")
+            public async Task Hangman([Leftover] string? type = null)
            {
-                Hangman hm;
-                try
-                {
-                    hm = new Hangman(type, _service.TermPool);
-                }
-                catch (TermNotFoundException)
+                if (!_service.StartHangman(ctx.Channel.Id, type, out var hangman))
                {
+                    await ReplyErrorLocalizedAsync(strs.hangman_running);
                    return;
                }

-                if (!_service.HangmanGames.TryAdd(ctx.Channel.Id, hm))
-                {
-                    hm.Dispose();
-                    await ReplyErrorLocalizedAsync(strs.hangman_running).ConfigureAwait(false);
-                    return;
-                }
-                hm.OnGameEnded += Hm_OnGameEnded;
-                hm.OnGuessFailed += Hm_OnGuessFailed;
-                hm.OnGuessSucceeded += Hm_OnGuessSucceeded;
-                hm.OnLetterAlreadyUsed += Hm_OnLetterAlreadyUsed;
-                _client.MessageReceived += _client_MessageReceived;
-
-                try
-                {
-                    await SendConfirmAsync(GetText(strs.hangman_game_started) + $" ({hm.TermType})",
-                        hm.ScrambledWord + "\n" + hm.GetHangman())
-                        .ConfigureAwait(false);
-                }
-                catch { }
-
-                await hm.EndedTask.ConfigureAwait(false);
-
-                _client.MessageReceived -= _client_MessageReceived;
-                _service.HangmanGames.TryRemove(ctx.Channel.Id, out _);
-                hm.Dispose();
-
-                Task _client_MessageReceived(SocketMessage msg)
-                {
-                    var _ = Task.Run(() =>
-                    {
-                        if (ctx.Channel.Id == msg.Channel.Id && !msg.Author.IsBot)
-                            return hm.Input(msg.Author.Id, msg.Author.ToString(), msg.Content);
-                        else
-                            return Task.CompletedTask;
-                    });
-                    return Task.CompletedTask;
-                }
-            }
-
-            Task Hm_OnGameEnded(Hangman game, string winner, ulong userId)
-            {
-                if (winner is null)
-                {
-                    var loseEmbed = _eb.Create().WithTitle($"Hangman Game ({game.TermType}) - Ended")
-                                             .WithDescription(Format.Bold("You lose."))
-                                             .AddField("It was", game.Term.GetWord())
-                                             .WithFooter(string.Join(" ", game.PreviousGuesses))
-                                             .WithErrorColor();
-
-                    if (Uri.IsWellFormedUriString(game.Term.ImageUrl, UriKind.Absolute))
-                        loseEmbed.WithImageUrl(game.Term.ImageUrl);
-
-                    return ctx.Channel.EmbedAsync(loseEmbed);
-                }
-
-                var reward = _gcs.Data.Hangman.CurrencyReward;
-                if (reward > 0)
-                    _cs.AddAsync(userId, "hangman win", reward, true);
-                
-                var winEmbed = _eb.Create().WithTitle($"Hangman Game ({game.TermType}) - Ended")
-                                             .WithDescription(Format.Bold($"{winner} Won."))
-                                             .AddField("It was", game.Term.GetWord())
-                                             .WithFooter(string.Join(" ", game.PreviousGuesses))
-                                             .WithOkColor();
-
-                if (Uri.IsWellFormedUriString(game.Term.ImageUrl, UriKind.Absolute))
-                    winEmbed.WithImageUrl(game.Term.ImageUrl);
-
-                return ctx.Channel.EmbedAsync(winEmbed);
-            }
-
-            private Task Hm_OnLetterAlreadyUsed(Hangman game, string user, char guess)
-            {
-                return SendErrorAsync($"Hangman Game ({game.TermType})", $"{user} Letter `{guess}` has already been used. You can guess again in 3 seconds.\n" + game.ScrambledWord + "\n" + game.GetHangman(),
-                                    footer: string.Join(" ", game.PreviousGuesses));
-            }
-
-            private Task Hm_OnGuessSucceeded(Hangman game, string user, char guess)
-            {
-                return SendConfirmAsync($"Hangman Game ({game.TermType})", $"{user} guessed a letter `{guess}`!\n" + game.ScrambledWord + "\n" + game.GetHangman(),
-                    footer: string.Join(" ", game.PreviousGuesses));
-            }
-
-            private Task Hm_OnGuessFailed(Hangman game, string user, char guess)
-            {
-                return SendErrorAsync($"Hangman Game ({game.TermType})", $"{user} Letter `{guess}` does not exist. You can guess again in 3 seconds.\n" + game.ScrambledWord + "\n" + game.GetHangman(),
-                                    footer: string.Join(" ", game.PreviousGuesses));
+                var eb = GetEmbed(_eb, hangman);
+                eb.WithDescription(GetText(strs.hangman_game_started));
+                await ctx.Channel.EmbedAsync(eb);
            }

            [NadekoCommand, Aliases]
            [RequireContext(ContextType.Guild)]
            public async Task HangmanStop()
            {
-                if (_service.HangmanGames.TryRemove(ctx.Channel.Id, out var removed))
+                if (await _service.StopHangman(ctx.Channel.Id))
                {
-                    await removed.Stop().ConfigureAwait(false);
                    await ReplyConfirmLocalizedAsync(strs.hangman_stopped).ConfigureAwait(false);
                }
            }
--- a/src/NadekoBot/Modules/Games/Services/GamesService.cs
+++ b/src/NadekoBot/Modules/Games/Services/GamesService.cs
@@ -4,7 +4,6 @@ using NadekoBot.Services;
 using NadekoBot.Extensions;
 using NadekoBot.Modules.Games.Common;
 using NadekoBot.Modules.Games.Common.Acrophobia;
-using NadekoBot.Modules.Games.Common.Hangman;
 using NadekoBot.Modules.Games.Common.Nunchi;
 using NadekoBot.Modules.Games.Common.Trivia;
 using Newtonsoft.Json;
@@ -12,7 +11,6 @@ using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
@@ -40,10 +38,6 @@ namespace NadekoBot.Modules.Games.Services

        //channelId, game
        public ConcurrentDictionary<ulong, AcrophobiaGame> AcrophobiaGames { get; } = new ConcurrentDictionary<ulong, AcrophobiaGame>();
-
-        public ConcurrentDictionary<ulong, Hangman> HangmanGames { get; } = new ConcurrentDictionary<ulong, Hangman>();
-        public TermPool TermPool { get; } = new TermPool();
-
        public ConcurrentDictionary<ulong, TriviaGame> RunningTrivias { get; } = new ConcurrentDictionary<ulong, TriviaGame>();
        public Dictionary<ulong, TicTacToe> TicTacToeGames { get; } = new Dictionary<ulong, TicTacToe>();
        public ConcurrentDictionary<ulong, TypingGame> RunningContests { get; } = new ConcurrentDictionary<ulong, TypingGame>();
--- a/src/NadekoBot/Modules/Help/Help.cs
+++ b/src/NadekoBot/Modules/Help/Help.cs
@@ -434,7 +434,7 @@ namespace NadekoBot.Modules.Help
        [NadekoCommand, Aliases]
        public async Task Donate()
        {
-            await ReplyErrorLocalizedAsync(strs.donate(PatreonUrl, PaypalUrl));
+            await ReplyConfirmLocalizedAsync(strs.donate(PatreonUrl, PaypalUrl));
        }
    }

--- a/src/NadekoBot/Modules/Help/Services/HelpService.cs
+++ b/src/NadekoBot/Modules/Help/Services/HelpService.cs
@@ -44,6 +44,11 @@ namespace NadekoBot.Modules.Help.Services
            {
                if (string.IsNullOrWhiteSpace(settings.DmHelpText) || settings.DmHelpText == "-")
                    return Task.CompletedTask;
+                
+                // only send dm help text if it contains one of the keywords, if they're specified
+                // if they're not, then reply to every DM
+                if (settings.DmHelpTextKeywords.Any() && !settings.DmHelpTextKeywords.Any(k => msg.Content.Contains(k)))
+                    return Task.CompletedTask;

                var rep = new ReplacementBuilder()
                    .WithOverride("%prefix%", () => _bss.Data.Prefix)
--- a/src/NadekoBot/Modules/Music/Music.cs
+++ b/src/NadekoBot/Modules/Music/Music.cs
@@ -125,7 +125,7 @@ namespace NadekoBot.Modules.Music
                queuedMessage?.DeleteAfter(10, _logService);
                if (mp.IsStopped)
                {
-                    var msg = await ReplyErrorLocalizedAsync(strs.queue_stopped(Format.Code(Prefix + "play")));
+                    var msg = await ReplyPendingLocalizedAsync(strs.queue_stopped(Format.Code(Prefix + "play")));
                    msg.DeleteAfter(10, _logService);
                }
            }
@@ -230,7 +230,7 @@ namespace NadekoBot.Modules.Music
                return;

            await _service.SetVolumeAsync(ctx.Guild.Id, vol);
-            await ReplyErrorLocalizedAsync(strs.volume_set(vol));
+            await ReplyConfirmLocalizedAsync(strs.volume_set(vol));
        }

        [NadekoCommand, Aliases]
--- a/src/NadekoBot/Modules/Nsfw/Common/Booru.cs
+++ b/src/NadekoBot/Modules/Nsfw/Common/Booru.cs
@@ -0,0 +1,15 @@
+namespace NadekoBot.Modules.Nsfw.Common
+{
+    public enum Booru
+    {
+        Safebooru,
+        E621,
+        Derpibooru,
+        Rule34,
+        Gelbooru,
+        Konachan,
+        Yandere,
+        Danbooru,
+        Sankaku
+    }
+}
--- a/src/NadekoBot/Modules/Nsfw/Common/DapiImageObject.cs
+++ b/src/NadekoBot/Modules/Nsfw/Common/DapiImageObject.cs
@@ -0,0 +1,18 @@
+using System.Text.Json.Serialization;
+
+namespace NadekoBot.Modules.Nsfw.Common
+{
+    public class DapiImageObject : IImageData
+    {
+        [JsonPropertyName("File_Url")]
+        public string FileUrl { get; set; }
+        public string Tags { get; set; }
+        [JsonPropertyName("Tag_String")]
+        public string TagString { get; set; }
+        public int Score { get; set; }
+        public string Rating { get; set; }
+        
+        public ImageData ToCachedImageData(Booru type)
+            => new ImageData(this.FileUrl, type, this.Tags?.Split(' ') ?? this.TagString?.Split(' '), Score.ToString() ?? Rating);
+    }
+}
--- a/src/NadekoBot/Modules/Nsfw/Common/DapiTag.cs
+++ b/src/NadekoBot/Modules/Nsfw/Common/DapiTag.cs
@@ -0,0 +1,15 @@
+using System.Text.Json.Serialization;
+
+namespace NadekoBot.Modules.Nsfw.Common
+{
+    public readonly struct DapiTag
+    {
+        public string Name { get; }
+
+        [JsonConstructor]
+        public DapiTag(string name)
+        {
+            Name = name;
+        }
+    }
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Kwoth	428429ff44	Fixed creating new users in the database when awarding currency	2021-11-03 16:27:48 +01:00
Kwoth	dc344caec6	Version upped to 3.0.8	2021-11-03 15:23:45 +01:00
Kwoth	2a4d55f81d	Merge branch 'v3-dev' into 'v3' Slots redesign nad images moved to images.yml See merge request Kwoth/nadekobot!181	2021-11-03 14:22:51 +00:00
Kwoth	d090aa23ee	Slots redesign nad images moved to images.yml	2021-11-03 14:22:51 +00:00
Kwoth	65062306c6	Merge branch 'tbodt-v3-patch-66982' into 'v3' Reduce required permissions for deleting quotes See merge request Kwoth/nadekobot!182	2021-10-30 11:54:03 +00:00
tbodt	9ae3b66fc2	Reduce required permissions for deleting quotes	2021-10-27 01:25:40 +00:00
Kwoth	c4ba43ec6d	Merge branch 'v3-dev' into 'v3' backport of public nsfw module See merge request Kwoth/nadekobot!176	2021-10-21 23:35:58 +00:00
Kwoth	1141791ce5	backport of public nsfw module	2021-10-21 23:35:58 +00:00
Kwoth	49f1ef7db0	Merge branch 'hokutochen-v3-patch-79292' into 'v3' Updated images for V3 updater See merge request Kwoth/nadekobot!179	2021-10-21 23:35:11 +00:00
Hokuto Chen	a70c35e101	Updated images for V3 updater	2021-10-21 23:35:11 +00:00
Kwoth	b61b1dbfaa	Merge branch 'memfix' into 'v3' Fixed memory counter not refreshing over time See merge request Kwoth/nadekobot!177	2021-10-17 22:56:10 +00:00
Kaoticz	92365fd22d	Fixed memory counter not refreshing over time	2021-10-17 22:56:10 +00:00
Kwoth	24a4745193	Merge branch 'v3-dev' into 'v3' Created VotesApi project nad re-worked vote rewards handling See merge request Kwoth/nadekobot!172	2021-10-15 22:06:30 +00:00
Kwoth	1af75fd813	Created VotesApi project nad re-worked vote rewards handling	2021-10-15 22:06:30 +00:00
Kwoth	18160164eb	Merge branch 'memsize' into 'v3' Corrected memory usage on StatusService See merge request Kwoth/nadekobot!175	2021-10-15 22:04:30 +00:00
Kaoticz	2fd7d97025	Corrected memory usage on StatusService	2021-10-15 22:04:30 +00:00
Kwoth	6ada15049d	Merge branch 'ban-kick-patch' into 'v3' TrimTo to avoid length limit for ban/kick reasons See merge request Kwoth/nadekobot!174	2021-10-13 17:51:08 +00:00
Alan Beatty	0ebc40b95c	TrimTo to avoid length limit for ban/kick reasons	2021-10-12 17:07:46 -05:00
Kwoth	02de25a931	Typo	2021-10-09 19:55:19 +02:00
Kwoth	0b395e9176	Merge branch 'v3' of https://gitlab.com/kwoth/nadekobot into v3	2021-10-09 19:49:26 +02:00
Kwoth	4532f992cd	Fixed field not preserving inline after string replacements. closes #308	2021-10-09 19:48:54 +02:00
Kwoth	34201f0558	Merge branch 'v3' into 'v3' Docs fix See merge request Kwoth/nadekobot!168	2021-10-09 17:43:18 +00:00
Hunter T	d2f4d63183	Docs fix	2021-10-09 17:43:18 +00:00
Kwoth	b41c014869	Merge branch 'Kieteyuku-v3-patch-34025' into 'v3' Use … in TrimTo to decrease necessary deletions See merge request Kwoth/nadekobot!171	2021-10-09 17:42:24 +00:00
Ene	d348347762	Update StringExtensions.cs	2021-10-08 20:20:50 +00:00
Kwoth	db7cf3d757	Upped version to 3.0.7, Updated changelog	2021-10-05 13:12:28 +02:00
Kwoth	83ea046d5f	Fixed %users% and %shard.usercount% placeholders not showing correct member count	2021-10-05 13:09:52 +02:00
Kwoth	d5c94424e9	Merge branch 'v3-docker' into 'v3' install youtube-dl through pip for a better availability of cdn See merge request Kwoth/nadekobot!165	2021-10-01 08:26:15 +00:00
Kwoth	ff95b3d00f	- .streamsclear re-added. It will remove all followed streams on the server. - .gifts now have 3 new ✂️ Haircut 🧻 ToiletPaper and 🥀 WiltedRose which reduce waifu's value - Added a new multiplier (waifu.multi.negative_gift_effect default 0.5, changeable via .config gambling or data/gambling.yml)	2021-09-30 08:53:15 +02:00
Veovis	4b5fa3bb04	install youtube-dl through pip for a better availability of cdn	2021-09-27 21:21:44 +02:00
Kwoth	52c9ec670d	Upped version to 3.0.6. Slightly updated hangman help string	2021-09-27 10:57:10 +02:00
Kwoth	1ac472c676	Urls will now properly work in embeds. Fixes #306	2021-09-27 10:52:14 +02:00
Kwoth	39f01a3164	Merge branch 'v3-dev' into 'v3' Hangman Rewrite See merge request Kwoth/nadekobot!164	2021-09-27 02:00:19 +00:00
Kwoth	486916944b	Hangman Rewrite	2021-09-27 02:00:19 +00:00
Kwoth	68e96cd1bb	Merge branch 'v3-docker' into 'v3' V3 docker See merge request Kwoth/nadekobot!163	2021-09-27 00:10:18 +00:00
Veovis	5a647d100a	V3 docker	2021-09-27 00:10:18 +00:00
Kwoth	a562a571e2	- .shopadd will now ignore negative price input - Make sure bot has manage roles permission for .xprr - Small cleanup	2021-09-22 23:07:23 +02:00
Kwoth	12146ad2da	Make sure the bot has manageroles permission for .aar	2021-09-22 22:41:00 +02:00
Kwoth	453ac3efd2	Re-did migration as the old one was wrong	2021-09-21 22:48:18 +02:00
Kwoth	c9e89e1911	- .logignore now supports targeting channels and users - .logignore now lists all ignored channels and users when no parameter is provided - Renamed and cleaned up some log-related fields	2021-09-21 22:39:24 +02:00
Kwoth	611817f78a	Yes, it's just a warning	2021-09-21 20:59:05 +02:00
Kwoth	2e66137f3e	Fixed an exception which was breaking repeater loop	2021-09-21 20:28:37 +02:00
Kwoth	2d92424dd4	Version upped to 3.0.5	2021-09-20 19:45:13 +02:00
Kwoth	ffba03adbe	Added guides on the different ways to run the bot on linux - contributed by Bark Ranger	2021-09-18 06:19:53 +02:00
Kwoth	76ebb87fb5	updated docs formatting and windows from source update guide	2021-09-17 19:02:18 +02:00
Kwoth	4a50c30c56	Fixed .logserver - should no longer throw an exception if you had no logsettings previously	2021-09-17 17:19:11 +02:00
Kwoth	e70a91ae60	Fixed images not automatically reloading on startup if the keys don't exist	2021-09-17 17:10:38 +02:00
Kwoth	3470762b30	woops, missed an extra bracket	2021-09-17 01:08:20 +02:00
Kwoth	2cbb4ecd3d	Version upped to 3.0.4	2021-09-16 23:10:19 +02:00
Kwoth	619bee811d	Fixed most of the commands which used wrong error color for confirm messages	2021-09-16 23:09:17 +02:00
Kwoth	a09be96200	Added DmHelpTextKeywords to data/bot.yml - Bot now sends dm help text ONLY if the message contains one of the keywords specified - If no keywords are specified, bot will reply to every DM (like before) - Fixed several commands which used error color for success confirmation messages	2021-09-16 22:52:04 +02:00
Kwoth	81254ed5f6	Added %server.boosters% and %server.boost_level% placeholders	2021-09-16 19:22:05 +02:00
Kwoth	d82e3bd444	Merge branch 'v3' of https://gitlab.com/kwoth/nadekobot into v3	2021-09-16 19:09:51 +02:00
Kwoth	9011646b02	Update responses.pt-BR.json (POEditor.com)	2021-09-16 17:09:46 +00:00
Kwoth	2a1f45819d	.waifugift pagination fixed - maximum number of pages properly scales with the number of items	2021-09-16 19:09:19 +02:00
Kwoth	d2d0cb9e03	- Possible fix for `.repeat` bug - Slight adjustment for repeater logic - Timer should no longer increase on some repeaters - Repeaters should no longer have periods when they're missing from the list	2021-09-16 07:19:08 +02:00