bot/add_character.py

@@ -1,27 +1,27 @@
 import requests
 from misskey.exceptions import MisskeyAPIException
 from client import client_connection
-from db_utils import insert_card
+from db_utils import insert_character
-from custom_types import Card
+from custom_types import Character
 from config import RARITY_TO_WEIGHT
 
 
-def add_card(
+def add_character(
         name: str,
         rarity: int,
         image_url: str) -> tuple[int, str]:
     '''
-    Adds a card to the database, uploading the image from a public URL to
+    Adds a character to the database, uploading the image from a public URL to
     the bot's Misskey Drive.
 
     Args:
-        name (str): Card name.
+        name (str): Character name.
-        rarity (int): Card rarity (e.g., 1-5).
+        rarity (int): Character rarity (e.g., 1-5).
         image_url (str): Public URL of the image from the post (e.g., from
             note['files'][i]['url']).
 
     Returns:
-        tuple[int, str]: Card ID and bot's Drive file_id.
+        tuple[int, str]: Character ID and bot's Drive file_id.
 
     Raises:
         ValueError: If inputs are invalid.
@@ -32,7 +32,7 @@ def add_card(
 
     # Validate inputs
     if not stripped_name:
-        raise ValueError('Card name cannot be empty.')
+        raise ValueError('Character name cannot be empty.')
     if rarity < 1:
         raise ValueError('Rarity must be a positive integer.')
     if rarity not in RARITY_TO_WEIGHT.keys():
@@ -55,10 +55,10 @@ def add_card(
                 from e
 
     # Insert into database
-    card_id = insert_card(
+    character_id = insert_character(
             stripped_name,
             rarity,
             RARITY_TO_WEIGHT[rarity],
             file_id
     )
-    return card_id, file_id
+    return character_id, file_id

bot/bot_app.py

@@ -12,9 +12,6 @@ if __name__ == '__main__':
     # Connect to DB
     db.connect()
 
-    # Setup default administrators
-    db.setup_administrators()
-
     print('Listening for notifications...')
     while True:
         if not process_notifications(client):

bot/config.py

@@ -1,6 +1,5 @@
 '''Essentials for the bot to function'''
 import configparser
-import json
 from os import environ, path
 
 
@@ -22,9 +21,7 @@ def get_config_file() -> str:
         raise ConfigError(f'Could not find {config_path}')
     return config_path
 
-
+def get_rarity_to_weight(config_section):
-def get_rarity_to_weight(
-        config_section: configparser.SectionProxy) -> dict[int, float]:
     """Parses Rarity_X keys from config and returns a {rarity: weight} dict."""
     rarity_weights = {}
     for key, value in config_section.items():
@@ -44,13 +41,12 @@ KEY = config['credentials']['Token']
 # Bot's Misskey instance URL
 INSTANCE = config['credentials']['Instance'].lower()
 
+# TODO: move this to db
 # Fedi handles in the traditional 'user@domain.tld' style, allows these users
 # to use extra admin exclusive commands with the bot
-ADMINS = json.loads(config['application']['DefaultAdmins'])
+ADMINS = config['application']['DefaultAdmins']
 # SQLite Database location
 DB_PATH = config['application']['DatabaseLocation']
-# Whether to enable the instance whitelist
-USE_WHITELIST = config['application']['UseWhitelist']
 
 NOTIFICATION_POLL_INTERVAL = int(config['notification']['PollInterval'])
 NOTIFICATION_BATCH_SIZE = int(config['notification']['BatchSize'])

bot/custom_types.py

@@ -5,7 +5,7 @@ BotResponse = TypedDict('BotResponse', {
     'attachment_urls': List[str] | None
 })
 
-Card = TypedDict('Card', {
+Character = TypedDict('Character', {
     'id': int,
     'name': str,
     'rarity': int,

bot/db_utils.py

@@ -1,7 +1,7 @@
 from random import choices
 import sqlite3
 import config
-from custom_types import Card
+from custom_types import Character
 
 DB_PATH = config.DB_PATH
 CONNECTION: sqlite3.Connection
@@ -18,38 +18,16 @@ def connect() -> None:
     CURSOR = CONNECTION.cursor()
 
 
-def setup_administrators() -> None:
+def get_random_character() -> Character | None:
-    '''Creates administrator players for each handle in the config file'''
+    ''' Gets a random character from the database'''
-    # Get default admins from config
+    CURSOR.execute('SELECT * FROM characters')
-    for username in config.ADMINS:
+    characters = CURSOR.fetchall()
-        player_id = get_player(username)
-        if player_id == 0:
-            # Create player if not exists
-            print(f'Creating administrator player: {username}')
-            CURSOR.execute(
-                'INSERT INTO players (username, has_rolled, is_administrator) \
-                    VALUES (?, ?, ?)',
-                (username, False, True)
-            )
-        else:
-            # Update is_administrator if exists
-            print(f'Granting administrator to player: {username}')
-            CURSOR.execute(
-                'UPDATE players SET is_administrator = 1 WHERE id = ?',
-                (player_id,)
-            )
 
-
+    if not characters:
-def get_random_card() -> Card | None:
-    ''' Gets a random card from the database'''
-    CURSOR.execute('SELECT * FROM cards')
-    cards = CURSOR.fetchall()
-
-    if not cards:
         return None
 
-    weights = [config.RARITY_TO_WEIGHT[c['rarity']] for c in cards]
+    weights = [config.RARITY_TO_WEIGHT[c['rarity']] for c in characters]
-    chosen = choices(cards, weights=weights, k=1)[0]
+    chosen = choices(characters, weights=weights, k=1)[0]
 
     return {
         'id': chosen['id'],
@@ -59,156 +37,77 @@ def get_random_card() -> Card | None:
         'image_url': chosen['file_id']
     }
 
-
 def get_player(username: str) -> int:
     '''Retrieve a player ID by username, or return None if not found.'''
-    CURSOR.execute(
+    CURSOR.execute('SELECT id FROM users WHERE username = ?', (username,))
-        'SELECT id FROM players WHERE username = ?',
+    user = CURSOR.fetchone()
-        (username,)
+    if user:
-    )
+        return int(user[0])
-    player = CURSOR.fetchone()
-    if player:
-        return int(player[0])
-    return 0
-
 
 def insert_player(username: str) -> int:
-    '''Insert a new player with default has_rolled = False and return their
+    '''Insert a new player with default has_rolled = False and return their user ID.'''
-    player ID.'''
     CURSOR.execute(
-        'INSERT INTO players (username, has_rolled) VALUES (?, ?)',
+        'INSERT INTO users (username, has_rolled) VALUES (?, ?)',
         (username, False)
     )
-    return CURSOR.lastrowid if CURSOR.lastrowid else 0
+    return CURSOR.lastrowid
-
 
 def delete_player(username: str) -> bool:
-    '''Permanently deletes a player and all their pulls.'''
+    '''Permanently deletes a user and all their pulls.'''
     CURSOR.execute(
-        'SELECT id FROM players WHERE username = ?',
+        'SELECT id FROM users WHERE username = ?',
         (username,)
     )
-    player = CURSOR.fetchone()
+    user = CURSOR.fetchone()
 
-    if not player:
+    user_id = user[0]
-        return False
-
-    player_id = player[0]
 
     # Delete pulls
     CURSOR.execute(
-        'DELETE FROM pulls WHERE player_id = ?',
+        'DELETE FROM pulls WHERE user_id = ?',
-        (player_id,)
+        (user_id,)
     )
 
-    # Delete player
+    # Delete user
     CURSOR.execute(
-        'DELETE FROM players WHERE id = ?',
+        'DELETE FROM users WHERE id = ?',
-        (player_id,)
+        (user_id,)
     )
 
     return True
 
 
-def ban_player(username: str) -> bool:
-    '''Adds a player to the ban list.'''
-    try:
-        CURSOR.execute(
-            'INSERT INTO banned_players (handle) VALUES (?)',
-            (username,)
-        )
-        return True
-    except sqlite3.IntegrityError:
-        return False
 
-
+def insert_character(
-def unban_player(username: str) -> bool:
-    '''Removes a player from the ban list.'''
-    CURSOR.execute(
-        'DELETE FROM banned_players WHERE handle = ?',
-        (username,)
-    )
-    return CURSOR.rowcount > 0
-
-
-def is_player_banned(username: str) -> bool:
-    CURSOR.execute(
-        'SELECT * FROM banned_players WHERE handle = ?',
-        (username,)
-    )
-    row = CURSOR.fetchone()
-    return row is not None
-
-
-def is_player_administrator(username: str) -> bool:
-    CURSOR.execute(
-        'SELECT is_administrator FROM players WHERE username = ? LIMIT 1',
-        (username,)
-    )
-    row = CURSOR.fetchone()
-    return row[0] if row else False
-
-
-def insert_card(
         name: str, rarity: int, weight: float, file_id: str) -> int:
-    '''Inserts a card'''
+    '''Inserts a character'''
     CURSOR.execute(
-        'INSERT INTO cards (name, rarity, weight, file_id) VALUES \
+        'INSERT INTO characters (name, rarity, weight, file_id) VALUES \
 (?, ?, ?, ?)',
         (name, rarity, weight, file_id)
     )
-    card_id = CURSOR.lastrowid
+    character_id = CURSOR.lastrowid
-    return card_id if card_id else 0
+    return character_id if character_id else 0
 
 
-def insert_pull(player_id: int, card_id: int) -> None:
+def insert_pull(user_id: int, character_id: int) -> None:
     '''Creates a pull in the database'''
     CURSOR.execute(
-        'INSERT INTO pulls (player_id, card_id) VALUES (?, ?)',
+        'INSERT INTO pulls (user_id, character_id) VALUES (?, ?)',
-        (player_id, card_id)
+        (user_id, character_id)
     )
 
 
-def get_last_rolled_at(player_id: int) -> int:
+def get_last_rolled_at(user_id: int) -> int:
-    '''Gets the timestamp when the player last rolled'''
+    '''Gets the timestamp when the user last rolled'''
     CURSOR.execute(
-        "SELECT timestamp FROM pulls WHERE player_id = ? ORDER BY timestamp \
+        "SELECT timestamp FROM pulls WHERE user_id = ? ORDER BY timestamp \
 DESC",
-        (player_id,))
+        (user_id,))
     row = CURSOR.fetchone()
     return row[0] if row else 0
 
 
-def add_to_whitelist(instance: str) -> bool:
-    '''Adds an instance to the whitelist, returns false if instance was already
-    present'''
-    try:
-        CURSOR.execute(
-            'INSERT INTO instance_whitelist (tld) VALUES (?)', (instance,)
-        )
-        return True
-    except sqlite3.IntegrityError:
-        return False
-
-
-def remove_from_whitelist(instance: str) -> bool:
-    '''Removes an instance to the whitelist, returns false if instance was not
-    present'''
-    CURSOR.execute(
-        'DELETE FROM instance_whitelist WHERE tld = ?', (instance,))
-    return CURSOR.rowcount > 0
-
-
-def is_whitelisted(instance: str) -> bool:
-    '''Checks whether an instance is in the whitelist'''
-    if instance == 'local':
-        return True
-    CURSOR.execute(
-        'SELECT * FROM instance_whitelist WHERE tld = ?', (instance,))
-    row = CURSOR.fetchone()
-    return row is not None
-
-
 def get_config(key: str) -> str:
     '''Reads the value for a specified config key from the db'''
     CURSOR.execute("SELECT value FROM config WHERE key = ?", (key,))

bot/notification.py

@@ -4,9 +4,9 @@ from typing import Dict, Any
 import misskey
 from misskey.exceptions import MisskeyAPIException
 
-from config import NOTIFICATION_BATCH_SIZE, USE_WHITELIST
+from config import NOTIFICATION_BATCH_SIZE
 from parsing import parse_notification
-from db_utils import get_config, set_config, is_whitelisted, is_player_banned
+from db_utils import get_config, set_config
 from response import generate_response
 from custom_types import BotResponse
 
@@ -24,7 +24,7 @@ def process_notification(
     host = user.get('host')  # None if local user
     instance = host if host else 'local'
 
-    if USE_WHITELIST and not is_whitelisted(instance):
+    if not (instance in WHITELISTED_INSTANCES or instance == 'local'):
         print(f'⚠️ Blocked notification from untrusted instance: {instance}')
         return
 
@@ -44,11 +44,6 @@ def process_notification(
     if not parsed_notification:
         return
 
-    author = parsed_notification['author']
-    if is_player_banned(author):
-        print(f'⚠️ Blocked notification from banned player: {author}')
-        return
-
     # Get the note Id to reply to
     note_id = notification.get('note', {}).get('id')
 

bot/parsing.py

@@ -24,8 +24,6 @@ def parse_notification(
     note_id = note_obj.get("id")
 
     note = note_text.strip().lower() if note_text else ""
-    # Split words into tokens
-    parts = note.split()
 
     # Check for both short and fully-qualified name mentions
     username_variants = [
@@ -33,16 +31,18 @@ def parse_notification(
         f'@{config.USER.split("@")[1]}'
     ]
 
-    # Notifs must consist of the initial mention and at least one other token
+    # Make sure the notification text explicitly mentions the bot
-    if len(parts) <= 1:
+    if not any(variant in note for variant in username_variants):
         return None
 
-    # Make sure the first token is a mention to the bot
+    # Find command and arguments after the mention
-    if not parts[0] in username_variants:
+    # Removes all mentions
-        return None
+    # regex = mentions that start with @ and may contain @domain
+    cleaned_text = re.sub(r"@\w+(?:@\S+)?", "", note).strip()
+    parts = cleaned_text.split()
 
-    command = parts[1].lower()
+    command = parts[0].lower() if parts else None
-    arguments = parts[2:] if len(parts) > 2 else []
+    arguments = parts[1:] if len(parts) > 1 else []
 
     return {
         'author': full_user,

bot/response.py

@@ -1,22 +1,22 @@
 from datetime import datetime, timedelta, timezone
 from typing import TypedDict, Any, List, Dict
-import db_utils as db
+from db_utils import get_player, insert_player, delete_player, insert_pull, get_last_rolled_at, \
-from add_card import add_card
+        get_random_character
+from add_character import add_character
 from config import GACHA_ROLL_INTERVAL
 from custom_types import BotResponse, ParsedNotification
 
 
 def do_roll(author: str) -> BotResponse:
-    '''Determines whether the user can roll, then pulls a random card'''
+    '''Determines whether the user can roll, then pulls a random character'''
-    user_id = db.get_player(author)
+    user_id = get_player(author)
     if not user_id:
         return {
-            'message': f'{author} 🛑 You haven’t signed up yet! Use the \
+        'message':f'{author} 🛑 You haven’t signed up yet! Use the `signup` command to start playing.',
-`signup` command to start playing.',
         'attachment_urls': None
         }
     # Get date of user's last roll
-    date = db.get_last_rolled_at(user_id)
+    date = get_last_rolled_at(user_id)
 
     # No date means it's users first roll
     if date:
@@ -45,43 +45,39 @@ def do_roll(author: str) -> BotResponse:
                 'attachment_urls': None
             }
 
-    card = db.get_random_card()
+    character = get_random_character()
 
-    if not card:
+    if not character:
         return {
             'message': f'{author} Uwaaa... something went wrong! No \
-cards found. 😿',
+characters found. 😿',
             'attachment_urls': None
         }
 
-    db.insert_pull(user_id, card['id'])
+    insert_pull(user_id, character['id'])
-    stars = '⭐️' * card['rarity']
+    stars = '⭐️' * character['rarity']
     return {
         'message': f'{author} 🎲 Congrats! You rolled {stars} \
-**{card['name']}**\nShe\'s all yours now~ 💖✨',
+**{character['name']}**\nShe\'s all yours now~ 💖✨',
-        'attachment_urls': [card['image_url']]
+        'attachment_urls': [character['image_url']]
     }
 
-
 def do_signup(author: str) -> BotResponse:
     '''Registers a new user if they haven’t signed up yet.'''
-    user_id = db.get_player(author)
+    user_id = get_player(author)
 
     if user_id:
         return {
-            'message': f'{author} 👀 You’re already signed up! Let the rolling \
+            'message':f'{author} 👀 You’re already signed up! Let the rolling begin~ 🎲',
-begin~ 🎲',
             'attachment_urls': None
         }
 
-    new_user_id = db.insert_player(author)
+    new_user_id = insert_player(author)
     return {
-            'message': f'{author} ✅ Signed up successfully! Your gacha \
+            'message': f'{author} ✅ Signed up successfully! Your gacha destiny begins now... ✨ Use the roll command to start!',
-destiny begins now... ✨ Use the roll command to start!',
             'attachment_urls': None
         }
 
-
 def is_float(val: Any) -> bool:
     '''Returns true if `val` can be converted to a float'''
     try:
@@ -95,14 +91,14 @@ def do_create(
         author: str,
         arguments: List[str],
         note_obj: Dict[str, Any]) -> BotResponse:
-    '''Creates a card'''
+    '''Creates a character'''
     # Example call from bot logic
     image_url = note_obj.get('files', [{}])[0].get('url') \
         if note_obj.get('files') else None
 
     if not image_url:
         return {
-            'message': f'{author} You need an image to create a card, \
+            'message': f'{author} You need an image to create a character, \
 dumbass.',
             'attachment_urls': None
         }
@@ -127,13 +123,13 @@ must be a decimal value between 0.0 and 1.0',
             'attachment_urls': None
         }
 
-    card_id, file_id = add_card(
+    character_id, file_id = add_character(
         name=arguments[0],
         rarity=int(arguments[1]),
         image_url=image_url
     )
     return {
-        'message': f'{author} Added {arguments[0]}, ID {card_id}.',
+        'message': f'{author} Added {arguments[0]}, ID {character_id}.',
         'attachment_urls': [file_id]
     }
 
@@ -142,117 +138,29 @@ def do_help(author: str) -> BotResponse:
     '''Provides a list of commands that the bot can do.'''
     return {
         'message':f'{author} Here\'s what I can do:\n \
-- `roll` Pulls a random card.\n\
+            - `roll` Pulls a random character.\
-- `create <name> <rarity>` Creates a card using a given image.\n\
+            - `create <name> <rarity>` Creates a character using a given image.\
-- `signup` Registers your account.\n\
+            - `signup` Registers your account.\
-- `delete_account` Deletes your account.\n\
+            - `delete_account` Deletes your account.\
             - `help` Shows this message',
             'attachment_urls': None
     }
             
-
 def delete_account(author: str) -> BotResponse:
     return {
-        'message': f'{author} ⚠️ This will permanently delete your account \
+        'message':f'{author} ⚠️ This will permanently delete your account and all your cards.\n'
-and all your cards.\n'
+        'If you’re sure, reply with `confirm_delete` to proceed.\n\n'
-        'If you\'re sure, reply with `confirm_delete_account` to proceed.\n\n'
         '**There is no undo.** Your gacha luck will be lost to the void... 💀✨',
         'attachment_urls': None
 
     }
 
-
 def confirm_delete(author: str) -> BotResponse:
-    db.delete_player(author)
+    
+    delete_player(author)
 
     return {
-        'message': f'{author} 🧼 Your account and all your cards have been \
+        'message':f'{author} 🧼 Your account and all your cards have been deleted. RIP your gacha history 🕊️✨',
-deleted. RIP your gacha history 🕊️✨',
-        'attachment_urls': None
-    }
-
-
-def do_whitelist(author: str, args: list[str]) -> BotResponse:
-    if len(args) == 0:
-        return {
-            'message': f'{author} Please specify an instance to whitelist',
-            'attachment_urls': None
-        }
-
-    if db.add_to_whitelist(args[0]):
-        return {
-            'message': f'{author} Whitelisted instance: {args[0]}',
-            'attachment_urls': None
-        }
-    else:
-        return {
-            'message': f'{author} Instance already whitelisted: {args[0]}',
-            'attachment_urls': None
-        }
-
-
-def do_unwhitelist(author: str, args: list[str]) -> BotResponse:
-    if len(args) == 0:
-        return {
-            'message': f'{author} Please specify an instance to remove from \
-the whitelist',
-            'attachment_urls': None
-        }
-
-    if db.remove_from_whitelist(args[0]):
-        return {
-            'message': f'{author} Unwhitelisted instance: {args[0]}',
-            'attachment_urls': None
-        }
-    else:
-        return {
-            'message': f'{author} Instance not whitelisted: {args[0]}',
-            'attachment_urls': None
-        }
-
-
-def do_ban(author: str, args: list[str]) -> BotResponse:
-    if len(args) == 0:
-        return {
-            'message': f'{author} Please specify a user to ban',
-            'attachment_urls': None
-        }
-
-    if db.is_player_administrator(args[0]):
-        return {
-            'message': f'{author} Cannot ban other administrators.',
-            'attachment_urls': None
-        }
-
-    if db.ban_player(args[0]):
-        # Delete banned player's account
-        db.delete_player(args[0])
-        return {
-            'message': f'{author} 🔨 **BONK!** Get banned, {args[0]}!',
-            'attachment_urls': None
-        }
-    else:
-        return {
-            'message': f'{author} Player is already banned: {args[0]}',
-            'attachment_urls': None
-        }
-
-
-def do_unban(author: str, args: list[str]) -> BotResponse:
-    if len(args) == 0:
-        return {
-            'message': f'{author} Please specify a user to unban',
-            'attachment_urls': None
-        }
-
-    if db.unban_player(args[0]):
-        return {
-            'message': f'{author} Player unbanned: {args[0]}!',
-            'attachment_urls': None
-        }
-    else:
-        return {
-            'message': f'{author} Player was not banned: {args[0]}',
         'attachment_urls': None
     }
 
@@ -263,23 +171,25 @@ def generate_response(notification: ParsedNotification) -> BotResponse | None:
 
     # Temporary response variable
     res: BotResponse | None = None
+    # TODO: Check if the user has an account
     author = notification['author']
-    player_id = db.get_player(author)
+    user_id = get_player(author)
     command = notification['command']
+    # Check if the user is an administrator
+    # user_is_administrator = user_is_administrator()
 
     # Unrestricted commands
     match command:
-        case 'roll':
-            res = do_roll(author)
         case 'signup':
             res = do_signup(author)
         case 'help':
             res = do_help(author)
+        case 'roll':
+            res = do_roll(author)
         case _:
             pass
 
-    # Commands beyond this point require the user to have an account
+    if not user_id:
-    if not player_id:
         return res
 
     # User commands
@@ -290,29 +200,15 @@ def generate_response(notification: ParsedNotification) -> BotResponse | None:
                 notification['arguments'],
                 notification['note_obj']
             )
+        case 'signup':
+            res = do_signup(author)
         case 'delete_account':
             res = delete_account(author)
-        case 'confirm_delete_account':
+        case 'confirm_delete':
             res = confirm_delete(author)
         case _:
             pass
-
+    # if not user_is_administrator:
-    # Commands beyond this point require the user to be an administrator
-    if not db.is_player_administrator(author):
     return res
 
-    # Admin commands
-    match command:
-        case 'whitelist':
-            res = do_whitelist(author, notification['arguments'])
-        case 'unwhitelist':
-            res = do_unwhitelist(author, notification['arguments'])
-        case 'ban':
-            res = do_ban(author, notification['arguments'])
-        case 'unban':
-            res = do_unban(author, notification['arguments'])
-        case _:
-            pass
-
     # Administrator commands go here
-    return res

docs/index.md

@@ -1,24 +0,0 @@
-# 🎲 Kemoverse Documentation
-
-Welcome to the developer documentation for **Kemoverse**, a gacha trading card game in the Fediverse!
-
-Features collectible cards, rarity-based pulls, and integration with Misskey.
-
-Name comes from Kemonomimi and Fediverse.
-
----
-
-## 📁 Table of Contents
-
-- [Installation](./install.md)
-- [Game Design](./design.md)
-- [Bot Architecture](./bot.md)
-- [Database Structure](./database.md)
-- [Card System](./cards.md)
-- [Web UI](./web.md)
-- [Theming and Assets](./theme.md)
-- [Contributing](./contributing.md)
-- [FAQ](./faq.md)
-
----
-

docs/install.md

@@ -1,83 +0,0 @@
-
-## 🧪 Installation
-
-### Download and install dependencies
-
-Clone the repo
-
-```sh
-git clone https://git.waifuism.life/waifu/kemoverse.git
-cd kemoverse
-```
-
-Setup a virtual environment (Optional, recommended)
-
-```sh
-python3 -m venv venv
-source venv/bin/activate
-```
-
-Install project dependencies via pip
-
-```sh
-python3 -m pip install -r requirements.txt
-```
-
-### Setup config file
-
-A sample config file is included with the project as a template: `example_config.ini`
-
-Create a copy of this file and replace its' values with your own. Consult the
-template for more information about individual config values and their meaning.
-
-Config files are environment-specific. Use `config_dev.ini` for development and
-`config_prod.ini` for production. Switch between environments using the
-`KEMOVERSE_ENV` environment variable.
-
-```sh
-cp example_config.ini config_dev.ini
-# Edit config_dev.ini
-```
-
-### Setup database
-
-To set up the database, run:
-
-```sh
-KEMOVERSE_ENV=dev python3 setup_db.py
-```
-
-### Run the bot
-
-```sh
-KEMOVERSE_ENV=dev ./startup.sh
-```
-
-If all goes well, you should now be able to interact with the bot.
-
-### Running in production
-
-To run the the in a production environment, use `KEMOVERSE_ENV=prod`. You will
-also need to create a `config_prod.ini` file and run the database setup step
-again if pointing prod to a different database. (you are pointing dev and prod
-to different databases, right? 🤨)
-
-### Updating
-
-To update the bot, first pull new changes from upstream:
-
-```sh
-git pull
-```
-
-Then run any database migrations. We recommend testing in dev beforehand to
-make sure nothing breaks in the update process.
-
-**Always backup your prod database before running any migrations!**
-
-```sh
-# Backup database file
-cp gacha_game_dev.db gacha_game_dev.db.bak
-# Run migrations
-KEMOVERSE_ENV=dev python3 setup_db.py
-```

docs/theme.md

@@ -1,33 +0,0 @@
-Welcome to the **Visual Identity** guide for the Kemoverse. This page contains the standard colors, logos, and graphic elements used across the game (cards, UI, web presence, bots, etc). Please follow these guidelines to ensure consistency.
-
----
-
-## 🟢 Primary Color Palette
-
-| Color Name     | Hex Code   | Usage                                |
-|----------------|------------|--------------------------------------|
-| Green  | `#5aa02c`  | Main buttons, links, headers         |
-| Midnight Black | `#1A1A1A`  | Backgrounds, dark mode               |
-| Misty White    | `#FAFAFA`  | Default backgrounds, light text bg  |
-| Soft Gray      | `#CCCCCC`  | Borders, placeholders, separators   |
-| Highlight Green | `#8dd35f`  | Alerts, emphasis, icons        |
-| Rarity Gold    | `#FFD700`  | Special rare cards, SSR outlines    |
-| Rarity Silver  | `#C0C0C0`  | Rare card text, stat glow effects   |
-
-> ✅ Use `Green` and `Misty White` for the standard UI. Avoid mixing in extra palettes unless explicitly needed.
-
----
-
-## 🖼 Logos
-
-### Main Logo
-
-<p align="center">
-  <img src="../web/static/logo.png" alt="Fediverse Gacha Bot Logo" width="300" height="auto">
-</p>
-
-- File: `web/static/logo.png`
-- Usage: Website header, favicon, bot avatar, watermark
-
-
----

example_config.ini

@@ -2,12 +2,9 @@
 [application]
 ; Comma separated list of fedi handles for any administrator users
 ; More can be added through the application
-DefaultAdmins    = ["@localadmin", "@remoteadmin@example.tld"]
+DefaultAdmins    = ['admin@example.tld']
 ; SQLite Database location
 DatabaseLocation = ./gacha_game.db
-; Whether to lmit access to the bot via an instance whitelist
-; The whitelist can be adjusted via the application
-UseWhitelist     = False
 
 [gacha]
 ; Number of seconds players have to wait between rolls

migrations/0003_rename_tables.sql

@@ -1,4 +0,0 @@
-ALTER TABLE users RENAME TO players;
-ALTER TABLE characters RENAME TO cards;
-ALTER TABLE pulls RENAME user_id TO player_id;
-ALTER TABLE pulls RENAME character_id TO card_id;

migrations/0004_add_administrators.sql

@@ -1 +0,0 @@
-ALTER TABLE players ADD COLUMN is_administrator BOOLEAN NOT NULL DEFAULT 0;

migrations/0005_add_whitelist.sql

@@ -1,7 +0,0 @@
-CREATE TABLE IF NOT EXISTS instance_whitelist (
-    tld TEXT UNIQUE PRIMARY KEY
-);
-
-CREATE TABLE IF NOT EXISTS banned_players (
-    handle TEXT UNIQUE PRIMARY KEY
-);

readme.md

@@ -1,15 +1,12 @@
 # Kemoverse
 
 A gacha-style bot for the Fediverse built with Python. Users can roll for characters, trade, duel, and perhaps engage with popularity-based mechanics. Currently designed for use with Misskey. Name comes from Kemonomimi and Fediverse.
-<p align="center">
-  <img src="./web/static/logo.png" alt="Fediverse Gacha Bot Logo" width="300" height="auto">
-</p>
 
-## 📝 Docs
+## Installation
 
-👉 [**Start reading the docs**](./docs/index.md)
+## Roadmap
 
-🤌 [**Install instructions for those in a rush**](docs/install.md)
+![Fediverse Gacha Bot Logo](./web/static/logo.png)
 
 ## 🔧 Features
 
@@ -18,11 +15,10 @@ A gacha-style bot for the Fediverse built with Python. Users can roll for charac
 - 🧠 Core database structure for cards
 - 📦 Basic support for storing pulls per player
 - ⏱️ Time-based limitations on rolls
-- ⚠️  Explicit account creation/deletion
 
 ### 🧩 In Progress
 - 📝 Whitelist system to limit access
-
+- ⚠️  Explicit account creation/deletion
 
 ## 🧠 Roadmap
 
@@ -61,6 +57,89 @@ A gacha-style bot for the Fediverse built with Python. Users can roll for charac
 
 The bot is meant to feel *light, fun, and competitive*. Mixing social, gacha and duel tactics.
 
+## 🧪 Installation
+
+### Download and install dependencies
+
+Clone the repo
+
+```sh
+git clone https://git.waifuism.life/waifu/kemoverse.git
+cd kemoverse
+```
+
+Setup a virtual environment (Optional, recommended)
+
+```sh
+python3 -m venv venv
+source venv/bin/activate
+```
+
+Install project dependencies via pip
+
+```sh
+python3 -m pip install -r requirements.txt
+```
+
+### Setup config file
+
+A sample config file is included with the project as a template: `example_config.ini`
+
+Create a copy of this file and replace its' values with your own. Consult the
+template for more information about individual config values and their meaning.
+
+Config files are environment-specific. Use `config_dev.ini` for development and
+`config_prod.ini` for production. Switch between environments using the
+`KEMOVERSE_ENV` environment variable.
+
+```sh
+cp example_config.ini config_dev.ini
+# Edit config_dev.ini
+```
+
+### Setup database
+
+To set up the database, run:
+
+```sh
+KEMOVERSE_ENV=dev python3 setup_db.py
+```
+
+### Run the bot
+
+```sh
+KEMOVERSE_ENV=dev ./startup.sh
+```
+
+If all goes well, you should now be able to interact with the bot.
+
+### Running in production
+
+To run the the in a production environment, use `KEMOVERSE_ENV=prod`. You will
+also need to create a `config_prod.ini` file and run the database setup step
+again if pointing prod to a different database. (you are pointing dev and prod
+to different databases, right? 🤨)
+
+### Updating
+
+To update the bot, first pull new changes from upstream:
+
+```sh
+git pull
+```
+
+Then run any database migrations. We recommend testing in dev beforehand to
+make sure nothing breaks in the update process.
+
+**Always backup your prod database before running any migrations!**
+
+```sh
+# Backup database file
+cp gacha_game_dev.db gacha_game_dev.db.bak
+# Run migrations
+KEMOVERSE_ENV=dev python3 setup_db.py
+```
+
 ```mermaid
 flowchart TD