WellDungeon Casino

main.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from collections import deque
from copy import deepcopy
from datetime import datetime, timedelta
from random import randint, getrandbits
from re import search
from signal import signal, SIGINT, SIGTERM
from sys import exit
from time import sleep
from threading import Event, Thread

import vk_api


class setInterval:
    def __init__(self, func, interval, immediately=False):
        self.func = func
        self.interval = interval
        self.immediately = immediately
        self.stop_event = Event()

        t = Thread(target=self._run)
        t.daemon = True
        t.start()

    def _run(self):
        if self.immediately:
            self.func()

        next_time = datetime.now() + timedelta(seconds=self.interval)
        while not self.stop_event.wait((next_time - datetime.now()).total_seconds()):
            next_time += timedelta(seconds=self.interval)
            self.func()

    def cancel(self):
        self.stop_event.set()


class Call:
    def __init__(self, fn, *args, **kwargs):
        self.fn = fn
        self.args = args
        self.kwargs = kwargs

    def __call__(self, *ignored_args, **ignored_kwargs):
        return self.fn(*self.args, **self.kwargs)


class TimedExecutionQueue:
    def __init__(self, times, interval):
        self.queue = deque()
        self.times = times
        self.interval = interval

        self.teq_state = [None] * 1000
        self.teq_state_id = 0

        t = Thread(target=self._monitor)
        t.daemon = True
        t.start()

    def append(self, fn, assign_state_id=False):
        if assign_state_id:
            if self.teq_state_id == 999:
                self.teq_state_id = 0

            self.queue.append([fn, self.teq_state_id])
            self.teq_state_id += 1
            return self.teq_state_id - 1

        else:
            self.queue.append([fn, None])

    def awt(self, state_id):
        while self.teq_state[state_id] == None:
            sleep(0.1)

        returned_value = deepcopy(self.teq_state[state_id])
        self.teq_state[state_id] = None
        return returned_value

    def _monitor(self):
        function_calls = 0
        last_finished_period = datetime.now() - timedelta(seconds=self.interval)

        while True:
            if function_calls > 0 and function_calls < self.times and (datetime.now() - last_finished_period).total_seconds() >= self.interval:
                function_calls = 0

            for [fn, state_id] in list(self.queue):
                returned_value = fn()
                if state_id != None:
                    self.teq_state[state_id] = returned_value

                self.queue.popleft()
                function_calls += 1

                if function_calls == self.times:
                    sleep(self.interval)
                    function_calls = 0

            sleep(0.1)

            if function_calls > 0 and function_calls < self.times:
                last_finished_period = datetime.now()


def auth_handler():
    key = input("Enter authentication code: ").strip()
    remember_device = True
    return key, remember_device


def main():
    login, password = "логин", "пароль"
    vk_session = vk_api.VkApi(
        login,
        password,
        app_id=2685278,
        scope=339968,
        auth_handler=auth_handler
    )

    try:
        vk_session.auth()

    except vk_api.AuthError as error_msg:
        print(error_msg)
        return


    vk = vk_session.get_api()
    API_QUEUE = TimedExecutionQueue(times=3, interval=1)
    messages_seen = []

    game_chat_peer_ids = list(
        map(
            lambda c: c["conversation"]["peer"]["id"],
            filter(
                lambda c: c["conversation"]["peer"]["type"] == "chat" and c["conversation"]["chat_settings"]["owner_id"] in [-182985865, 7812327],
                API_QUEUE.awt(API_QUEUE.append(Call(vk.messages.getConversations, offset=0, count=50, filter="all"), assign_state_id=True))["items"]
            )
        )
    )

    for peer_id in game_chat_peer_ids:
        messages_seen += API_QUEUE.awt(API_QUEUE.append(Call(vk.messages.getHistory, count=20, peer_id=peer_id), assign_state_id=True))["items"]


    def ad_send():
        MESSAGE = "Проверь свою удачу, путник!\
        \n❗Напиши мне в ЛС \"Участвую\", если понял и принял условия ниже (единожды, сообщение обязательно должно дойти)❗, и отправь мне немного золота.\
        \nЕсли артефакт покажет 55 или больше, я верну тебе увеличенную сумму. \
        \nНасколько увеличенную? Смотри: я удвою твою сумму, если она меньше 30000, в противном случае добавлю три четверти. Если произойдёт настоящее чудо, я её утрою. Всё просто.\
        \nЧто за артефакт? Хм, именно он будет выступать гарантом в наших с тобой \"отношениях\".\
        \nОчень умный и очень надменный дядька сделал шар, внутрь которого поместил вихрь, и назвал этот опус в честь себя любимого. Вихрь выбирает случайное число и показывает его. \
        \nСпрашивал у этого деда, как работает эта штука... Ничего не понятно, но очень интересно. В общем, выиграешь ты или проиграешь решит случай. Рискнём?\
        \nА, и про налоги не забудь, от них даже гоблины скрыться не могут.\
        \n(Бот неофициальный, в случае сбоев и ошибок писать в ЛС коротко и по делу, всё решим и поможем)\
        \n(ПЕРЕЗАПУСКАЕТСЯ В КОНЦЕ КАЖДОГО ЧАСА, БУДЬТЕ ВНИМАТЕЛЬНЫ!)\
        "

        for peer_id in game_chat_peer_ids:
            API_QUEUE.append(Call(vk.messages.send, peer_id=peer_id, random_id=getrandbits(64), message=MESSAGE, attachment="photo582429669_457239019"))


    def prize_amount(gold_recieved, dice_roll):
        if dice_roll in [55, 77, 99]:
            return gold_recieved * 3.0

        else:
            if gold_recieved < 30000:
                return gold_recieved * 2.0

            else:
                return gold_recieved * 1.75


    def exit_gracefully(timers_to_cancel):
        for timer in timers_to_cancel:
            timer.cancel()

        exit(0)


    AD_SEND_TIMER = setInterval(ad_send, 60 * 60, immediately=True)
    PRIZE_DISPENCE_QUEUE = TimedExecutionQueue(times=1, interval=62)

    signal(SIGINT, Call(exit_gracefully, [AD_SEND_TIMER]))
    signal(SIGTERM, Call(exit_gracefully, [AD_SEND_TIMER]))


    while True:
        try:
            for peer_id in game_chat_peer_ids:
                if len(messages_seen) > 100:
                    messages_seen = messages_seen[20:]

                all_messages = API_QUEUE.awt(API_QUEUE.append(Call(vk.messages.getHistory, count=20, peer_id=peer_id), assign_state_id=True))["items"]
                messages_filtered = list(filter(lambda m: m not in messages_seen, all_messages))
                messages_seen += messages_filtered

                if len(messages_filtered) > 0:
                    for msg in messages_filtered:
                        if msg["from_id"] == -183040898 and "[id582429669|Весёлый]," in msg["text"] and search(r"получено (\d+) золота", msg["text"]):
                            gold_recieved = int(search(r"получено (\d+) золота", msg["text"]).group(1))
                            sender_id, _ = search(r"от игрока \[(.+)\]", msg["text"]).group(1).split("|")
                            sender_id = int(sender_id[2:])

                            private_chat = API_QUEUE.awt(API_QUEUE.append(Call(vk.messages.getHistory, count=20, peer_id=sender_id), assign_state_id=True))["items"]
                            messages_from_sender = list(filter(lambda m: m["from_id"] == sender_id, private_chat))

                            if not messages_from_sender:
                                API_QUEUE.append(Call(vk.messages.send, peer_id=peer_id, random_id=getrandbits(64), message=f"[id{sender_id}|@id{sender_id}], мне необходимо, чтобы ты написал мне в ЛС \"Участвую\", чтобы я мог работать с тобой. Но сейчас — ты не согласился с условиями, и я не могу узнать, выиграл ты или проиграл, как и не могу отправить тебе золото. Но ты не расстраивайся, я оценил твой безвозмездный подарок! 👋🏻"))
                                continue

                            message_to_forward = messages_from_sender[0]["id"]
                            dice_roll = randint(0, 100)

                            if dice_roll >= 55:
                                API_QUEUE.append(Call(vk.messages.send, peer_id=peer_id, random_id=getrandbits(64), message=f"[id{sender_id}|@id{sender_id}], артефакт показал {dice_roll} 👏🏻! {'И вот оно, чудо 🍀!' if dice_roll in [55, 77, 99] else ''} Отсчитать и упаковать твой выигрыш ({round(prize_amount(gold_recieved, dice_roll))} золота) я уже поручил своим гоблинам. Выдам, когда они закончат, и когда подойдёт твоя очередь."))
                                PRIZE_DISPENCE_QUEUE.append(
                                    Call(API_QUEUE.append, Call(vk.messages.send, peer_id=peer_id, random_id=getrandbits(64), message=f"Передать {round(prize_amount(gold_recieved, dice_roll))} золота", forward_messages=[message_to_forward]))
                                )

                            else:
                                API_QUEUE.append(Call(vk.messages.send, peer_id=peer_id, random_id=getrandbits(64), message=f"[id{sender_id}|@id{sender_id}], артефакт показал {dice_roll} 🙁. Не расстраивайся, повезёт в следующий раз."))

            sleep(0.1)

        except KeyboardInterrupt:
            exit_gracefully([AD_SEND_TIMER])


if __name__ == "__main__":
    main()

requirements.txt

vk-api==11.7.0