League of Legends (LoL) is a popular multiplayer online battle arena game where two teams of five compete to destroy each other’s base. A recurring problem is smurfing — experienced players creating new low-ranked accounts to play against beginners, causing unfair matches.

This project detects smurfs by analyzing gameplay data. The pipeline includes scraping player ranks from op.gg, collecting match data via the Riot API, cleaning and enriching the data with ranks, engineering features like KDA ratio and gold per minute, and training outlier detection models (Isolation Forest, One-Class SVM, Local Outlier Factor, Neural Networks).

Use the Riot-API to:

from bs4 import BeautifulSoup
import glob
import os

# Path to offline-saved HTML files
path = os.path.join(os.path.dirname(__file__), "NameScrapeTxt")
files = sorted(glob.glob(os.path.join(path, "*.txt")))

players = []

for file in files:
    with open(file, "r", encoding="utf-8") as f:
        soup = BeautifulSoup(f.read(), "html.parser")
    for row in soup.select("tr"):
        name = row.select_one("span.whitespace-pre-wrap.text-gray-900")
        tag = row.select_one("span.text-gray-500.truncate")
        if name and tag:
            players.append(f"{name.text.strip()}{tag.text.strip()}")

# Remove duplicates and save results
players = list(set(players))
print(players)
print(f"{len(players)} Spieler gefunden")

with open("alle_spieler.txt", "w", encoding="utf-8") as f:
    for p in players:
        f.write(p + "\n")
                            

from riotwatcher import LolWatcher, RiotWatcher
from dotenv import load_dotenv
import os, json, time
from tqdm import tqdm

# Load API key and region info
load_dotenv()
api_key = os.getenv("RIOT_API_KEY")
platform = os.getenv("PLATFORM")
region = os.getenv("REGION")

lol_watcher = LolWatcher(api_key)
riot_watcher = RiotWatcher(api_key)

def riot_api_request(func, *args, max_retries=3, sleep=2, **kwargs):
    """Generic retry wrapper for Riot API calls"""
    for attempt in range(1, max_retries+1):
        try:
            return func(*args, **kwargs)
        except Exception as e:
            print(f"[Retry {attempt}/{max_retries}] Error: {e}")
            if attempt == max_retries:
                raise
            time.sleep(sleep)

# Example: Fetch match IDs
account = riot_api_request(
    riot_watcher.account.by_riot_id,
    platform, "SummonerName", "TAG"
)
match_ids = riot_api_request(
    lol_watcher.match.matchlist_by_puuid,
    platform, account["puuid"], count=5
)
print(match_ids)
                    

This step transforms raw gameplay data into structured machine learning input. It includes several preprocessing steps and the design of domain-specific features to detect smurf behavior effectively.

The following features are some of our derived or selected from the match data

These features are designed to capture mechanical skill, team contribution, and player dominance in matches

To simulate smurf behavior (since no ground truth exists), we engineered a custom score (`smurf_score`) and binary label (`smurf_flag`) using domain knowledge and rules such as

Features were combined into a weighted score to assign weakly supervised labels

These labels are used as training or evaluation targets for classification and anomaly detection models

The primary goal was to implement one docker compose File (docker-compose.yml). There was only one issue with the certification. This command initiates a one-time execution of the Certbot client within a temporary Docker container to obtain a TLS/SSL certificate from the Let’s Encrypt Certificate Authority

docker run --rm \
  -v /data/compose/9/web:/usr/share/nginx/html \
  -v /data/compose/9/letsencrypt:/etc/letsencrypt \
  certbot/certbot:latest certonly \
    --non-interactive --agree-tos --keep-until-expiring \
    --email "*****@****.de" \
    --webroot -w /usr/share/nginx/html \
    -d eneemr.sabuncuoglu.de
                    

The Docker compose YAML

version: "3.8"

services:
  nginx_http:
    image: nginx:1.27-alpine
    container_name: nginx_http
    restart: unless-stopped
    ports:
      - "80:80"  # Serve HTTP traffic on IPv4/IPv6
    volumes:
      - /data/compose/9/web:/usr/share/nginx/html:ro  # Static web content (read-only)

  certbot:
    image: certbot/certbot:latest
    container_name: certbot
    restart: unless-stopped
    volumes:
      - /data/compose/9/web:/usr/share/nginx/html          # Webroot for ACME HTTP-01 challenge
      - /data/compose/9/letsencrypt:/etc/letsencrypt       # Persistent certificate/key storage
    entrypoint: ["/bin/sh", "-lc"]
    command:
      - >
        set -e;  # Abort on any command error
        # Ensure required dirs exist
        mkdir -p /usr/share/nginx/html/.well-known/acme-challenge /etc/letsencrypt;

        # Initial certificate issuance (only if no cert present)
        if [ ! -f /etc/letsencrypt/live/eneemr.sabuncuoglu.de/fullchain.pem ]; then
          echo "[certbot] requesting initial certificate for eneemr.sabuncuoglu.de";
          certbot certonly \
            --non-interactive --agree-tos --keep-until-expiring \
            --email "******@*****.de" \
            --webroot -w /usr/share/nginx/html \
            -d eneemr.sabuncuoglu.de || true;  # Ignore failure to avoid container crash
        fi;

        # Renewal loop: run every 12h
        while :; do
          # Attempt silent renewal
          certbot renew --webroot -w /usr/share/nginx/html --quiet || true;
          sleep 12h;
        done

  certbot_renew:
    image: certbot/certbot:latest
    container_name: certbot_renew
    restart: unless-stopped
    volumes:
      - /data/compose/9/web:/usr/share/nginx/html
      - /data/compose/9/letsencrypt:/etc/letsencrypt
    command:
      - /bin/sh
      - -lc
      - |
        # Renewal-only loop — no initial issuance logic
        while :; do
          certbot renew --webroot -w /usr/share/nginx/html --quiet || true
          sleep 12h
        done

  nginx_https_redirect:
    image: nginx:1.27-alpine
    container_name: nginx_https_redirect
    restart: unless-stopped
    depends_on:
      - certbot  # Ensure certbot container has run at least once
    ports:
      - "443:443"  # Serve HTTPS connections
    volumes:
      - /data/compose/9/letsencrypt:/etc/letsencrypt:ro  # Read-only mount of issued certs
    entrypoint: ["/bin/sh", "-lc"]
    command:
      - >
        set -e;

        # Wait until certificate + key exist before starting Nginx
        while [ ! -f /etc/letsencrypt/live/eneemr.sabuncuoglu.de/fullchain.pem ] ||
              [ ! -f /etc/letsencrypt/live/eneemr.sabuncuoglu.de/privkey.pem ]; do
          echo "[https] waiting for certificates...";
          sleep 5;
        done;

        # Generate minimal nginx.conf: TLS termination with 308 redirect to HTTP
        printf '%s\n' '
        worker_processes auto;
        error_log  /var/log/nginx/error.log warn;
        pid        /var/run/nginx.pid;
        events { worker_connections 1024; }
        http {
          include       /etc/nginx/mime.types;
          default_type  application/octet-stream;
          access_log /var/log/nginx/access.log;
          sendfile on;
          keepalive_timeout 65;
          server_tokens off;
          server {
            listen 443 ssl http2;
            listen [::]:443 ssl http2;
            server_name eneemr.sabuncuoglu.de;
            ssl_certificate     /etc/letsencrypt/live/eneemr.sabuncuoglu.de/fullchain.pem;
            ssl_certificate_key /etc/letsencrypt/live/eneemr.sabuncuoglu.de/privkey.pem;
            ssl_session_timeout 1d;
            ssl_session_cache shared:SSL:10m;
            ssl_protocols TLSv1.2 TLSv1.3;
            ssl_ciphers HIGH:!aNULL:!MD5;
            ssl_prefer_server_ciphers on;
            location / { return 308 http://$$host$$request_uri; }  # Preserve method/body in redirect
          }
        }' > /etc/nginx/nginx.conf;

        exec nginx -g 'daemon off;'