Бот для Ёлочки 2016 (исходный код)

**object** · 29.11.2016, 23:33

Всем привет.

Публикую исходный код моего бота, который использовался в онлайн боте для ёлочки 2016.

Надеюсь кому-то это пригодится.
Вы можете использовать бот для своих нужд или развернуть еще один онлайн бот.

Надеюсь это кому-то будет интересно.

Я не несу ответственности за ваши действия и причерченный ущерб другим игрокам.
Этот исходный код выложен для учебных целей, а так же для поднятия интереса к разработке ботов.

Я запускал это дело под 2 и 3 Питоном.
В зависимостях: requests >= 2, six
self.client (он же HTTPClient) можно смело заменить на requests.get|post..
Работоспособность бота актуальна на сентябрь, октябрь. дальше проект был приостановлен

Если вы копируете этот код на другой форум или поднимаете своего бота, пожалуйста, укажите автора - object

Скопировать код с форума

Код:

# coding=utf-8
import collections
import datetime
import hashlib
import json

import six


API_ID = 5124326
BASE_URL = 'http://elka2016-vk.ereality.org'
ADDED_PARAMS = [
    "suid", "uid", "aid", "authKey",
    "sessionKey", "clientPlatform", "clientVersion"
]


def compare_time(timestamp):
    return convert_timestamp_to_datetime(timestamp) < datetime.datetime.now()


def load_flash_vars(page, start="vars =", end=";"):
    vars = page.split(start)[1].split(end)[0]
    return json.loads(vars)


def convert_timestamp_to_datetime(timestamp):
    return datetime.datetime.fromtimestamp(timestamp)


def md5(string, need_decode=False):
    if need_decode:
        string = string.decode("utf-8")
    m = hashlib.md5()
    m.update(string.encode("utf-8"))
    return m.hexdigest()


def for_array(arr):
    result = "&".join(
        ["{}={}".format(k, v) for k, v in enumerate(arr)]
    )
    return md5(result)


def for_dict(dic):
    srt = collections.OrderedDict(sorted(dic.items()))
    result = "&".join(
        ["{}={}".format(k, v) for k, v in six.iteritems(srt)]
    )
    return md5(result.decode("utf-8"))


def calcParamsArraySign(data):
    data = collections.OrderedDict(sorted(data.items()))
    result = []
    for key, value in six.iteritems(data):
        if isinstance(value, list):
            value = for_array(value)
        elif isinstance(value, dict):
            value = for_dict(value)
        result.append("{}={}".format(key, value))
    return md5("&".join(result))


def sign(body, controller, action):
    result = body["params"].copy()
    for param in ADDED_PARAMS:
        result[param] = body[param]
    result["action"] = action.lower()
    result["controller"] = controller.lower()
    return calcParamsArraySign(result)


class ElochkaBot:
    def request(self, controller, action, params, return_json=False, **kwargs):
        body = kwargs.get('body') or {
            "sessionKey": self.flash_vars['sessionKey'],
            "authKey": self.flash_vars['authKey'],
            "suid": self.flash_vars['suid'],
            "version": self.flash_vars['version'],
            "aid": API_ID,
            "clientPlatform": "flash",
            "clientVersion": "2016-04-08 16:45:32",
            "uid": self.flash_vars['uid'],
            "params": params
        }
        body['sign'] = sign(body, controller, action)
        url = "{}/{}/{}/".format(BASE_URL, controller, action)
        result = self.client.post(url, json=body)

        # case: У сервера внутри вываливается внутренняя ошибка
        # и он отдает нам игровой JSON + описание своей ошибки.
        # В результате мы получаем не валидный JSON.
        if 'HTTP_RAW_POST_DATA' in result.text:
            result = result.text.split('}{"error":{')[0] + '}'

        return json.loads(result) if return_json else result

    def auth(self):
        url = BASE_URL + '/iframe?api_id={}&viewer_id={}&auth_key={}'.format(
            API_ID, self.user_id, self.auth_key)

        page = self.client.get(url).text
        if 'sessionKey' in page:
            setattr(self, 'flash_vars', load_flash_vars(page))
            self.is_auth = True

    def load_game_data(self):
        params = {
            "friendIds": [],
            "socialData": {
                "sex": "m",
                "country": "",
                "city": "",
                "bdate": ""
            },
            "online": []
        }

        result = self.request('game', 'init', params, return_json=True)

        setattr(self, 'data', result['data'])

    def is_bird_ready(self, bird_id):
        bird_id = 'bird' + str(bird_id)
        bird = self.data['user']['dc'][bird_id]
        time = convert_timestamp_to_datetime(bird['timer'])
        return time < datetime.datetime.now()

    def is_fishing_ready(self, fish_id):
        fishing = self.data['user']['fishing']['holes'].get(str(fish_id))
        if fishing is None:
            return False
        next_time = convert_timestamp_to_datetime(fishing)
        return next_time < datetime.datetime.now()

    def is_daily_bonus_available(self):
        return self.data['user']['dailyBonus']['used'] != 1

    def is_flower_available(self, flower_id):
        flowers = self.data['user']['flowers'].get(str(flower_id))
        if flowers:
            time_end = convert_timestamp_to_datetime(flowers['timeEnd'])
            return time_end < datetime.datetime.now()
        return False

    def get_all_flower_info(self):
        all_flowers = []
        flowers = self.data['user']['flowers']
        for id in flowers:
            all_flowers.append({
                'id': id,
                'endTime': flowers[id]['timeEnd'],
                'is_ended':
                    convert_timestamp_to_datetime(flowers[id]['timeEnd'])
                    < datetime.datetime.now()
            })
        return all_flowers

    def get_friend_info(self, friend_id):
        params = {
            "userId": friend_id,
            "chestId": 1
        }
        info = self.request('friend', 'getFriend', params)

        if 'User not found' in info:
            return None

        return json.loads(info).get('data')

    def plant_flower(self, flower_id):
        params = {"flowerId": flower_id}
        result = self.request('game', 'flowerPlant', params)
        return 'screenMoney' in result

    def collect_flower(self, flower_id):
        params = {"flowerId": flower_id}
        result = self.request('game', 'flowerHarvest', params)
        return 'award' in result

    def collect_magic_spark(self):
        body = {
            "sessionKey": self.data['user']['session'],
            "authKey": self.flash_vars['authKey'],
            "suid": self.flash_vars['suid'],
            "version": self.flash_vars['version'],
            "aid": API_ID,
            "clientPlatform": "flash",
            "clientVersion": "2016-04-08 16:45:32",
            "uid": self.flash_vars['uid'],
            "params": {
                "awardId": 1,
                "sparkId": 1
            }
        }
        result = self.request('game', 'magicSparkUse', None, body=body)
        return 'award' in result

    def collect_fish(self, fish_id):
        params = {"holeId": 1}
        start_answer = self.request('game', 'fishingStart', params)

        # case: Рыбалка недоступна
        if 'Next try at' in start_answer:
            return False

        params["success"] = 1
        end_answer = self.request('game', 'fishingEnd', params)
        # TODO: Количество рыбы: data.award.resouce.ID
        return 'award' in end_answer

    def collect_bird(self, bird_id):
        return self.collect_dyn("bird" + str(bird_id))

    def is_magic_spark_available(self):
        timestamp = self.data['user']['magicSpark']['1']
        time = convert_timestamp_to_datetime(timestamp)
        return time < datetime.datetime.now()

    def is_snow_available(self):
        snow_time = int(self.data['user']['dc']['snowmaiden']['timer'])
        return compare_time(snow_time)

    def get_ready_expeditions_id(self):
        return [id for id, time in self.data['user']['expeditions'].items()
                if time > 0 and compare_time(time)]

    def expedition_start(self, screen_id, exp_id):
        params = {"id": exp_id, "screenId": screen_id}
        result = self.request('expedition', 'start', params)
        return 'success' in result

    def expedition_speedup(self, exp_id):
        params = {"id": exp_id, "free": 1}
        result = self.request('expedition', 'speedup', params)
        return 'expeditionTime' in result

    def expedition_end(self, screen_id, exp_id):
        params = {"id": exp_id, "screenId": screen_id}
        result = self.request('expedition', 'end', params)
        return 'expeditionAward' in result

    def collect_dyn(self, dyn_name, **kwargs):
        body = {
            "sessionKey": self.data['user']['session'],
            "authKey": self.flash_vars['authKey'],
            "suid": self.flash_vars['suid'],
            "version": self.flash_vars['version'],
            "aid": API_ID,
            "clientPlatform": "flash",
            "clientVersion": "2016-04-08 16:45:32",
            "uid": self.flash_vars['uid'],
            "params": {
                "dynCounterName": dyn_name,
            }
        }
        if kwargs:
            body['params'].update(kwargs)

        result = self.request('game', 'exchangeDynCounter', None, body=body)
        return 'award' in result

    def collect_snow(self):
        return self.collect_dyn('snowmaiden', count=60)

    def collect_daily_bonus(self, slot_id=1):
        body = {
            "sessionKey": self.data['user']['session'],
            "authKey": self.flash_vars['authKey'],
            "suid": self.flash_vars['suid'],
            "version": self.flash_vars['version'],
            "aid": API_ID,
            "clientPlatform": "flash",
            "clientVersion": "2016-04-08 16:45:32",
            "uid": self.flash_vars['uid'],
            "params": {
                "slotId": slot_id,
                "slotCounter": 1
            }
        }
        result = self.request('game', 'openDailyBonusSlot', None, body=body)
        if 'award' in result:
            body['params'] = {}
            result = self.request('game', 'finishDailyBonus', None, body=body)
            return 'screenMoney' in result
        return False

    def feed_pet(self, food_id, pet_id, direct_feed=0):
        params = {"foodId": food_id, "petId": pet_id, "directFeed": 0}
        result = self.request('game', 'petFeed', params)
        return 'screenMoney' in result

    def get_friend_info(self, friend_id):
        params = {
            "userId": friend_id,
            "chestId": 1
        }
        info = self.request('friend', 'getFriend', params)

        if 'User not found' in info:
            return None

        return json.loads(info).get('data')

    def collect_mail(self):
        result = self.request('mail', 'flushInbox', {})
        return '"success":1' in result

    def collect_parrot(self):
        body = {
            "sessionKey": self.data['user']['session'],
            "authKey": self.flash_vars['authKey'],
            "suid": self.flash_vars['suid'],
            "version": self.flash_vars['version'],
            "aid": API_ID,
            "clientPlatform": "flash",
            "clientVersion": "2016-04-08 16:45:32",
            "uid": self.flash_vars['uid'],
            "params": {}
        }
        result = self.request('game', 'parrotGetAward', None, body=body)
        return 'award' in result

    def collect_palm(self, palm_id):
        result = self.collect_dyn("palm%s" % palm_id)
        return result

    def collect_carnaval(self):
        """Собираем мистический подарок."""
        body = {
            "sessionKey": self.data['user']['session'],
            "authKey": self.flash_vars['authKey'],
            "suid": self.flash_vars['suid'],
            "version": self.flash_vars['version'],
            "aid": API_ID,
            "clientPlatform": "flash",
            "clientVersion": "2016-04-08 16:45:32",
            "uid": self.flash_vars['uid'],
            "params": {}
        }
        result = self.request('game', 'carnivalGeneratorGetAward', None,
                              body=body)
        return 'award' in result

    def roll_wheel_of_fortune(self, slot_id):
        """Вращает колесо фортуны.

        :param int slot_id: Номер колеса.
        """
        body = {
            "sessionKey": self.data['user']['session'],
            "authKey": self.flash_vars['authKey'],
            "suid": self.flash_vars['suid'],
            "version": self.flash_vars['version'],
            "aid": API_ID,
            "clientPlatform": "flash",
            "clientVersion": "2016-04-08 16:45:32",
            "uid": self.flash_vars['uid'],
            "params": {"slotId": slot_id}
        }
        result = self.request('game', 'wheelOfFortuneRotate', None,
                              body=body)
        return 'sectorId' in result

    def collect_magician(self):
        """Собирает зеленые листочки у снегурочки на карнавале."""
        return self.collect_dyn("magician")

Эмиель · 11.02.2017, 10:13

А где достать самого бота?

**object** · 12.02.2017, 18:09

Цитата:

Сообщение от Эмиель


	А где достать самого бота?

В 1 посте приведен код для бота.
Далее вам нужно самому "собрать" бота и запустить.

AstrBlaze · 10.07.2017, 20:50

Можете посоветовать годную литературу по Питону для написания подобного?