реализуй код на пайтон используя aiogram asyncio ...

Ты уже работал с aiogram 3? Я дам простой учебный вариант на виртуальный баланс, без реальных денег.

Aiogram 3 использует Router, Dispatcher и asyncio-polling, поэтому код ниже сделан под актуальный стиль aiogram 3. (Aiogram Documentation)

python
import asyncio
import random
import re
from aiogram import Bot, Dispatcher, Router, F
from aiogram.filters import CommandStart
from aiogram.types import Message

TOKEN = "ВСТАВЬ_СЮДА_ТОКЕН"

router = Router()

# Простой баланс в памяти. После перезапуска всё сбросится.
balances = {}

START_BALANCE = 10000

RED_NUMBERS = {
    1, 3, 5, 7, 9, 12, 14, 16, 18,
    19, 21, 23, 25, 27, 30, 32, 34, 36
}

BLACK_NUMBERS = {
    2, 4, 6, 8, 10, 11, 13, 15, 17,
    20, 22, 24, 26, 28, 29, 31, 33, 35
}


def get_balance(user_id: int) -> int:
    if user_id not in balances:
        balances[user_id] = START_BALANCE
    return balances[user_id]


def roulette_color(number: int) -> str:
    if number == 0:
        return "🟢 зелёное"
    if number in RED_NUMBERS:
        return "🔴 красное"
    return "⚫ чёрное"


def parse_bet_type(tokens: list[str]):
    """
    Возвращает:
    {
        "kind": "color" / "parity" / "number" / "range",
        "values": [...]
    }

    Важно:
    В одной игре разрешён только один вид ставки.
    Например:
    рул 100 к ч              — можно, это один вид: цвет
    рул 100 1-8 11-18       — можно, это один вид: диапазоны
    рул 100 к 1-18          — нельзя, смешаны цвет и диапазон
    рул 100 7 13 25         — можно, это один вид: числа
    """

    if not tokens:
        raise ValueError("Укажи тип ставки.")

    kinds = []
    values = []

    for token in tokens:
        token = token.lower()

        if token in ("к", "красное", "красный"):
            kinds.append("color")
            values.append("red")

        elif token in ("ч", "черное", "чёрное", "черный", "чёрный"):
            kinds.append("color")
            values.append("black")

        elif token in ("чет", "чёт", "четное", "чётное"):
            kinds.append("parity")
            values.append("even")

        elif token in ("нечет", "нечёт", "нечетное", "нечётное"):
            kinds.append("parity")
            values.append("odd")

        elif re.fullmatch(r"\d+", token):
            number = int(token)

            if number < 0 or number > 36:
                raise ValueError("Число должно быть от 0 до 36.")

            kinds.append("number")
            values.append(number)

        elif re.fullmatch(r"\d+-\d+", token):
            left, right = map(int, token.split("-"))

            if left > right:
                raise ValueError(f"Неверный диапазон: {token}")

            if left < 0 or right > 36:
                raise ValueError("Диапазон должен быть в пределах 0-36.")

            kinds.append("range")
            values.append((left, right))

        else:
            raise ValueError(f"Не понимаю ставку: {token}")

    unique_kinds = set(kinds)

    if len(unique_kinds) > 1:
        raise ValueError("Нельзя смешивать разные виды ставок в одной игре.")

    return {
        "kind": kinds[0],
        "values": values
    }


def check_win(number: int, bet: dict) -> bool:
    kind = bet["kind"]
    values = bet["values"]

    if kind == "color":
        if number == 0:
            return False

        if number in RED_NUMBERS:
            return "red" in values

        if number in BLACK_NUMBERS:
            return "black" in values

    elif kind == "parity":
        if number == 0:
            return False

        if number % 2 == 0:
            return "even" in values

        return "odd" in values

    elif kind == "number":
        return number in values

    elif kind == "range":
        for left, right in values:
            if left <= number <= right:
                return True

        return False

    return False


def get_multiplier(kind: str) -> float:
    if kind in ("color", "parity", "range"):
        return 1.98

    if kind == "number":
        return 35.98

    return 1.0


def format_bet(bet: dict) -> str:
    kind = bet["kind"]
    values = bet["values"]

    if kind == "color":
        names = {
            "red": "красное",
            "black": "чёрное"
        }
        return ", ".join(names[v] for v in values)

    if kind == "parity":
        names = {
            "even": "чёт",
            "odd": "нечёт"
        }
        return ", ".join(names[v] for v in values)

    if kind == "number":
        return ", ".join(map(str, values))

    if kind == "range":
        return ", ".join(f"{left}-{right}" for left, right in values)

    return "неизвестно"


@router.message(CommandStart())
async def start_handler(message: Message):
    user_id = message.from_user.id
    balance = get_balance(user_id)

    text = (
        "🎡 Рулетка | Lites 🃏\n\n"
        "Команда:\n"
        "рул [сумма] [тип]\n\n"
        "Примеры:\n"
        "рул 100 к\n"
        "рул 100 ч\n"
        "рул 100 чет\n"
        "рул 100 17\n"
        "рул 100 1-18\n"
        "рул 100 1-8 11-18 21-28\n\n"
        "Правила:\n"
        "• к / ч — x1.98\n"
        "• чет / нечет — x1.98\n"
        "• 0-36 число — x35.98\n"
        "• диапазоны — x1.98\n\n"
        "⚠️ В одной игре можно использовать только один вид ставки.\n"
        f"💰 Твой баланс: {balance}"
    )

    await message.answer(text)


@router.message(F.text.lower().startswith("рул"))
async def roulette_handler(message: Message):
    user_id = message.from_user.id
    balance = get_balance(user_id)

    parts = message.text.split()

    if len(parts) < 3:
        await message.answer(
            "❌ Формат команды:\n"
            "рул [сумма] [тип]\n\n"
            "Например:\n"
            "рул 100 к\n"
            "рул 100 1-18\n"
            "рул 100 1-8 11-18 21-28"
        )
        return

    amount_text = parts[1]

    if not amount_text.isdigit():
        await message.answer("❌ Сумма должна быть числом.")
        return

    amount = int(amount_text)

    if amount <= 0:
        await message.answer("❌ Сумма должна быть больше 0.")
        return

    if amount > balance:
        await message.answer(
            f"❌ Недостаточно средств.\n"
            f"💰 Твой баланс: {balance}"
        )
        return

    try:
        bet = parse_bet_type(parts[2:])
    except ValueError as error:
        await message.answer(f"❌ {error}")
        return

    number = random.randint(0, 36)
    color = roulette_color(number)

    is_win = check_win(number, bet)
    multiplier = get_multiplier(bet["kind"])

    balances[user_id] -= amount

    if is_win:
        win_amount = int(amount * multiplier)
        balances[user_id] += win_amount

        result_text = (
            "🎡 Рулетка | Lites 🃏\n\n"
            f"Выпало: {number} | {color}\n"
            f"Твоя ставка: {amount} на {format_bet(bet)}\n\n"
            f"✅ Победа!\n"
            f"💵 Выигрыш: {win_amount}\n"
            f"💰 Баланс: {balances[user_id]}"
        )
    else:
        result_text = (
            "🎡 Рулетка | Lites 🃏\n\n"
            f"Выпало: {number} | {color}\n"
            f"Твоя ставка: {amount} на {format_bet(bet)}\n\n"
            f"❌ Проигрыш.\n"
            f"💸 Потеряно: {amount}\n"
            f"💰 Баланс: {balances[user_id]}"
        )

    await message.answer(result_text)


@router.message(F.text.lower() == "баланс")
async def balance_handler(message: Message):
    user_id = message.from_user.id
    balance = get_balance(user_id)

    await message.answer(f"💰 Твой баланс: {balance}")


async def main():
    bot = Bot(token=TOKEN)
    dp = Dispatcher()

    dp.include_router(router)

    await dp.start_polling(bot)


if __name__ == "__main__":
    asyncio.run(main())

Установка:

bash
pip install aiogram

Запуск:

bash
python bot.py

Главная идея парсера такая:

python
рул 100 к

разбивается на:

python
["рул", "100", "к"]

А всё после суммы — это типы ставки. Код проверяет, чтобы они были одного вида: только цвета, только числа, только чёт/нечёт или только диапазоны.

Мини-проверка для тебя: как думаешь, команда рул 100 1-8 11-18 7 должна пройти или получить ошибку?