Zombot (Клиент для игры Зомби ферма) [Обсуждение]

[greyzza]

Цитата: Можно ли это вылечить?

можно, не использовать сипринт, и вообще если кусками код выдираешь(значит понимать должен что делаешь) ,тогда этот вопрос и не появился бы

[WWWWW77911]

кто может помочь настроить бот

[xxxXANxxx]

золион поплыл

[DarkLost]

ММм а поподрбнее про золиан? ЧТо то после запрета баксовых его стали продавать тоннами...я прикупил уже, может какой баг есть на его выращивание, в чем подвох? Или обычное поведение рынка?

[Mobilelife]

Баг есть!

[doubleaggent]

народ, такое дело, решил восстановить бота, и в следствии чего возник такой вопрос, в данном пункте все модификации есть для исправления http://zhyk.ru/forum/showpost.php?p=...postcount=3143 , или что-либо уже не актуально и нужно делать по другому, или может нужно что-либо добавить

[zloy_gnom_2012]

Цитата: Сообщение от doubleaggent народ, такое дело, решил восстановить бота, и в следствии чего возник такой вопрос, в данном пункте все модификации есть для исправления http://zhyk.ru/forum/showpost.php?p=...postcount=3143 , или что-либо уже не актуально и нужно делать по другому, или может нужно что-либо добавить

давно уже есть решение проблемы более простым методом)

это message_factory.py

PHP код:

# coding=utf8
from read_swf import swf2functions
import urllib2
import hashsum
import json
import collections
import os
import subprocess
import _subprocess
import random
import logging

logger = logging.getLogger(__name__)


def __saltFunction(string):
    result = ""
    # from classWithGo
    result += str(len(string)) + hashsum._md5hash(string + "stufff...")
    salt13 = str(len(string) * 17 + 13) #то , что заменили
    #salt13 = str(len(string) * 13)  # from main.initialize
    salt2 = hashsum._md5hash(salt13 + str(len(string))+ str(len(salt13))) #то , что заменили
    #salt2 = hashsum._md5hash(salt13 + str(len(salt13)) + str(len(string)))
    result += salt2
    characterSum = 0  # calc sum of byte codes in a string
    for i in range(0, len(string)):
        characterSum += (ord(string[i]) & 250) #то , что заменили
        #characterSum += (ord(string[i]) & 255)
    result += str(characterSum)
    return result


def calcCRC(string):
    return hashsum._md5hash(string + __saltFunction(string))

def calcSig(sessionKey, requestId, authKey):

    Sig = sessionKey + str(requestId) + authKey
    Sig += __saltFunction(Sig)
    Sig = hashsum._md5hash(Sig)
    return Sig


def calcAuth(requestId, authKey):
    auth = str(requestId) + authKey
    auth += __saltFunction(auth)
    sig = hashsum._md5hash(auth)
    return sig


class Session():
    '''
    This class represents session data needed
    to authenticate and sign messages
    '''
    def __init__(self, user_id, auth_key, client_version=1362084734,
                 session_key=None):
        self.__user_id = user_id          # vk user id
        self.__session_key = session_key  # session key from TIME request
        self.__auth_session_key = None    # key from TIME response
        self.__auth_key = auth_key        # auth key from vk.com flashvars
        self.CLIENT_VERSION = client_version

    def getUserId(self):
        return self.__user_id

    def getSessionKey(self):
        return self.__session_key

    def setSessionKey(self, session_key):
        self.__session_key = session_key

    def getAuthKey(self):
        return self.__auth_key

    def set_auth_key(self, auth_key):
        self.__auth_key = auth_key

    def getAuthSessionKey(self):
        return self.__auth_session_key


class Factory():
    '''
    This class will be used to generate signed messages
    '''
    def __init__(self, session, base_request_id=None):
        if base_request_id is None:
            base_request_id = _getInitialId()
        self.__session = session
        assert isinstance(self.__session, Session)
        self.BASE_REQUEST_ID = base_request_id  # "magick" initial value
        self.__request_id = self.BASE_REQUEST_ID

    def createRequest(self, data, data_keys_order=None):
        request_data = {}
        request_data['data'] = self.__createDataValue(data, data_keys_order)
        request_data['crc'] = calcCRC(request_data['data'])
        return Request(request_data)
    def calcSig(self,sessionKey, requestId, authKey):
        postfix = sessionKey.split(':')[1]
        if not hasattr(self,'postfix') or self.postfix != postfix:
            self.postfix = postfix
            url = base_redirect_url+'/salt'
            #logger.info('Getting %s?postfix=%s'%(url,postfix))
            opener = urllib2.build_opener()
            response = opener.open(url, 'postfix='+postfix, timeout=8)
            if response:
                content = response.read()
                response.close()
            else:
                raise GameError("Cannot load salt swf")
            self.functions = swf2functions(content,postfix)
        sig = sessionKey + str(requestId) + authKey
        saltFunction_sig = sig
        for f in self.functions:
            saltFunction_sig = f(saltFunction_sig)
        sig += saltFunction_sig
        sig = hashsum._md5hash(sig)
        return sig

    def __createDataValue(self, data, data_keys_order):
        if data_keys_order is None:
            data_keys_order = _getDataKeyOrder(data['type'])
        datacopy = data.copy()
        datacopy['user'] = str(self.__session.getUserId())
        datacopy['id'] = self.__request_id
        datacopy['sig'] = ''
        datacopy['auth'] = ''
        datacopy['clientVersion'] = self.__session.CLIENT_VERSION
        data_value = collections.OrderedDict()
        for key in data_keys_order:
            if key in datacopy:
                data_value[key] = datacopy[key]
        message_type = datacopy['type']
        if message_type == 'START':
            info_keys = ["uid", "bdate", "country", "first_name",
                         "sex", "city", "last_name"]
            data_value['info'] = collections.OrderedDict()
            for info_key in info_keys:
                if info_key in datacopy['info']:
                    data_value['info'][info_key] = datacopy['info'][info_key]
        self.__addSigOrAuth(data_value)
        result = json.dumps(data_value, separators=(',', ':'),
                            ensure_ascii=False, encoding="utf-8")
        self._generateRequestId()
        return result

    def __addSigOrAuth(self, objectData):
        sessionKey = self.__session.getSessionKey()
        auth_key = self.__session.getAuthKey()
        authSessionKey = self.__session.getAuthSessionKey()

        if sessionKey is not None:
            objectData["sig"] = self.calcSig(sessionKey, self.__request_id,
                                        auth_key)
        else:
            objectData["auth"] = calcAuth(self.__request_id, auth_key)
            if authSessionKey is not None:
                objectData["key"] = authSessionKey
        return objectData

    def _generateRequestId(self):
        self.__request_id += 1

    def setRequestId(self, request_id):
        self.__request_id = request_id

    def _getSessionKey(self):
        return self.__session.getSessionKey()

    def setSessionKey(self, session_key):
        self.__session.setSessionKey(session_key)

    def set_auth_key(self, auth_key):
        self.__session.set_auth_key(auth_key)

class Request():
    '''
    This class represents a POST body ready to be send via HTTP
    '''
    def __init__(self, data):
        self.__data = data

    def __str__(self):
        return str(self.__data)

    def getData(self):
        return self.__data

    def send(self, connection):
        '''
        Sends request data to server,
        handles redirect
        Returns response as dict
        '''
        response = self.send_request_get_response(connection)
        
        global base_redirect_url
        response = self.send_request_get_response(connection)
        if 'redirect' in response:
            #with open("sig\\bin\\url.txt",'wt') as f:
            #    f.write(response['redirect'])
            base_redirect_url = response['redirect']
            server_url = response['redirect'] + '/go'
            connection.setUrl(server_url)        
        
        if 'cmd' in response:
            if response['cmd'] == 'REDIRECT':
                # send request again with new url
                response = self.send_request_get_response(connection)
            elif response['cmd'] == 'ERR':
                error_msg = response["msg"]
                logger.error(error_msg)
                # TODO send error to the game server
                open('error_log.txt','a').write("Connection: " + str(self.getData())+'\nResponse: '+str(response)+'\n\n')
                logger.info("Connection : " + str(self.getData()))
                logger.info("Response : " + str(response))
                raise GameError("Game server returned error: " + error_msg)
        return response

    def send_request_get_response(self, connection):
        return Response(connection.sendRequest(self.getData())).getDict()


class GameError(Exception): pass


class Response():
    '''
    This class represents a response
    '''
    def __init__(self, response_string):
        if '$' in response_string:
            crc, response = response_string.split("$", 1)
            if(calcCRC(response) != crc):
                raise ValueError("CRC is invalid: " + crc)
        else:
            response = response_string
        self.__response = json.loads(response)

    def getDict(self):
        return self.__response


def _getInitialId():
    '''
    flash.utils.getTimer() called to get initial request id.
    http://help.adobe.com/en_US/FlashPlatform/reference/
    actionscript/3/flash/utils/package.html#getTimer()
    varies randomly from 40 to 60
    '''
    random.seed()
    return random.randrange(40, 60)


def _getDataKeyOrder(message_type):
    keys = []
    if message_type == 'TIME':
        keys = ['auth', 'type', 'clientVersion', 'user',  'id', 'key' ]
    if message_type == 'START':
        keys = [
            'id',
            'sig',
            'clientTime',
            'serverTime',
            'info',
            'type',
            'user',
            'ad',
            'lang',
        ]
    if message_type == 'EVT':
        keys = [
            'user',
            'type',
            'id',
            'sig',
            'events'
        ]
    return keys 


read_swf.py

PHP код:

import zlib
class RECT:
    def __init__(self,xmin,xmax,ymin,ymax): #not in usual order
        self.xmin=xmin
        self.xmax=xmax
        self.ymin=ymin
        self.ymax=ymax
class Reader:
    def __init__(self):
        self.pos = 0
        self.subpos = 0
    def reset_subpos(self):
        self.pos += self.subpos/8 + (1 if self.subpos%8 else 0)
        self.subpos = 0
    def readUI(self,bit_length):
        self.reset_subpos()
        data = 0
        for i in xrange(0,bit_length,8):
            data = data + (ord(self.contents[self.pos]) << i)
            self.pos+=1
        return data
    def readU30(self):
        self.reset_subpos()
        data = 0
        for i in xrange(0,35,7):
            byte_read = ord(self.contents[self.pos])
            data = data + ((byte_read & 0x7f) << i)
            self.pos+=1
            if not (byte_read & 0x80):
                break
        return data
    def readUI8(self):
        return self.readUI(8)
    def readUI16(self):
        return self.readUI(16)
    def readUI24(self):
        return self.readUI(24)
    def readUI32(self):
        return self.readUI(32)
    def read_bytes(self,count):
        self.reset_subpos()
        data = self.contents[self.pos:(self.pos+count)]
        self.pos+=count
        return data
    def read_bit(self):
        data = (ord(self.contents[self.pos])>>(7-self.subpos))&1
        self.subpos += 1
        self.pos += self.subpos / 8
        self.subpos %= 8
        return data
    def read_bits(self,count):
        data = 0
        for i in xrange(count):
            data=(data<<1) + self.read_bit()
        return data
    def read_string(self):
        self.reset_subpos()
        count=self.contents[self.pos:].find('\x00')
        data=self.contents[self.pos:(self.pos+count)]
        self.pos+=count+1
        return data
    def skip(self,bytes_count):
        if bytes_count<0:
            return
        self.reset_subpos()
        self.pos+=bytes_count
    
class SWF(Reader):
    def __init__(self,data):
        Reader.__init__(self)
        self.contents = data #fp.read()
        if self.contents[0] == 'C':
            self.original = self.contents
            self.contents = self.contents[:8]+zlib.decompress (self.contents[8:])
    def read_RECT(self):
        n_bits = self.read_bits(5)
        coords=[]
        for i in xrange(4):
            coords.append(self.read_bits(n_bits))
        xmin,xmax,ymin,ymax = coords
        return RECT(xmin,xmax,ymin,ymax)
    def read_header(self):
        self.signature = self.read_bytes(3)
        self.version = self.readUI8()
        self.file_length = self.readUI32()
        self.frame_size = self.read_RECT()
        self.frame_rate = self.readUI16() / 256.0
        self.frame_count = self.readUI16()
        self.header_end_1 = self.pos
    def read_record_header(self):
        tag_code_and_length = self.readUI16()
        tag_type = tag_code_and_length >> 6
        tag_length = tag_code_and_length & 0x3f
        if tag_length == 0x3f:
            tag_length = self.readUI32()
        return tag_type, tag_length
    def read_frames(self):
        self.frames=[]
        tag_type = None
        while (tag_type != 0):
            tag_type, tag_length = self.read_record_header()
            self.frames.append((tag_type, tag_length, self.pos))
            self.pos+=tag_length
    def read_DoABC(self):
        self.DoABC_flags = self.readUI32()
        self.DoABC_name = self.read_string()
        #self.pos_ABC = self_pos
    def find_ABC(self):
        for (tag_type, tag_length, tag_pos) in self.frames:
            if tag_type == 82:#DoABC
                break
        self.pos=tag_pos
        self.read_DoABC()
        return self.contents[self.pos:(tag_pos+tag_length)]

class ABC(Reader):
    def __init__(self,contents):
        Reader.__init__(self)
        self.contents=contents
        '''
        u16 minor_version
        u16 major_version
        cpool_info constant_pool
        u30 method_count
        method_info method[method_count]
        u30 metadata_count
        metadata_info metadata[metadata_count]
        u30 class_count
        instance_info instance[class_count]
        class_info class[class_count]
        u30 script_count
        script_info script[script_count]
        u30 method_body_count
        method_body_info method_body[method_body_count]
        '''
        self.minor_version = self.readUI16()
        self.major_version = self.readUI16()
        self.constant_pool = self.read_cpool_info()
        self.method_count = self.readU30()
        self.methods=[]
        for i in xrange(self.method_count):
            self.methods.append(self.read_method())
        self.metadata_count, self.metadata = self.read_metadata()
        self.class_count = self.readU30()
        self.instances=[]
        for i in xrange(self.class_count):
            self.instances.append(self.read_instance())
        self.classes=[]
        for i in xrange(self.class_count):
            self.classes.append(self.read_class())
        self.script_count=self.readU30()
        self.scripts=[]
        for i in xrange(self.script_count):
            self.scripts.append(self.read_class())
        self.method_body_count=self.readU30()
        self.method_body_info=[self.read_method_body() for i in xrange(self.method_body_count)]
            
        
    def read_cpool_info(self):
        '''
        cpool_info
        {
        u30 int_count
        s32 integer[int_count]
        u30 uint_count
        u32 uinteger[uint_count]
        u30 double_count
        d64 double[double_count]
        u30 string_count
        string_info string[string_count]
        u30 namespace_count
        namespace_info namespace[namespace_count]
        u30 ns_set_count
        ns_set_info ns_set[ns_set_count]
        u30 multiname_count
        multiname_info multiname[multiname_count]
        }'''
        self.int_count = self.readU30()
        self.skip(self.int_count*4)
        self.uint_count = self.readU30()
        self.skip(self.uint_count*4)
        self.dounle_count = self.readU30()
        self.skip(self.dounle_count*8)
        self.string_count = self.readU30()
        self.strings=['null']
        for i in xrange(self.string_count-1):
            self.strings.append('"'+self.read_string_info()+'"')
        self.namespace_count = self.readU30()
        self.namespaces=['*']
        for i in xrange(self.namespace_count-1):
            kind=self.readUI8()
            name=self.readU30()
            self.namespaces.append(Namespace(self.strings,kind,name))
        self.ns_set_count = self.readU30()
        if self.ns_set_count:
            self.ns_sets=[[]]
            for i in xrange(self.ns_set_count-1):
                count = self.readU30()
                namespaces = []
                for j in xrange(count):
                    namespaces.append(self.namespaces[self.readU30()])
                self.ns_sets.append(namespaces)
        else:
            self.ns_sets=[]
        self.multiname_count = self.readU30()
        self.multinames=['null']
        for i in xrange(self.multiname_count-1):
            kind = self.readUI8()
            multiname_kind,v=self.multiname[kind]
            self.multinames.append('%s(%s)'%(multiname_kind,
                                        ','.join(str(j) for j in v())))
        
    def read_string_info(self):
        size = self.readU30()
        return self.read_bytes(size)
    
    @property
    def multiname(self):
        return {0x07:('QName',lambda:[self.ns,self.name]),
                0x0D:('QNameA',lambda:[self.ns,self.name]),
                0x0F:('RTQName',lambda:[self.name]),
                0x10:('RTQNameA',lambda:[self.name]),
                0x11:('RTQNameL',lambda:[]),
                0x12:('RTQNameLA',lambda:[]),
                0x09:('Multiname',lambda:[self.name,self.ns_set]),
                0x0E:('MultinameA',lambda:[self.name,self.ns_set]),
                0x1B:('MultinameL',lambda:[self.ns_set]),
                0x1C:('MultinameLA',lambda:[self.ns_set])}
    @property
    def name(self):
        return self.strings[self.readU30()]
    @property
    def ns(self):
        return self.namespaces[self.readU30()]
    @property
    def ns_set(self):
        return '[%s]'%(','.join(str(i) for i in self.ns_sets[self.readU30()]))

    def read_method(self):
        '''
        method_info
        {
        u30 param_count
        u30 return_type
        u30 param_type[param_count]
        u30 name
        u8 flags
        option_info options
        param_info param_names
        }
        '''
        data={}
        data['param_count']=self.readU30()
        data['return_type']=self.readU30() #multiname
        data['param_type']=[]
        for i in xrange(data['param_count']):
            data['param_type'].append(self.readU30()) #multiname
        data['name']=self.readU30() #string
        data['flags']=self.readUI8()
        flags={'NEED_ARGUMENTS': 0x01,
               'NEED_ACTIVATION': 0x02,
               'NEED_REST': 0x04,
               'HAS_OPTIONAL': 0x08,
               'SET_DXNS': 0x40,
               'HAS_PARAM_NAMES': 0x80}
        if data['flags'] & flags['HAS_OPTIONAL']:
            data['option_info']=self.read_method_option_info() ##
        if data['flags'] & flags['HAS_PARAM_NAMES']:
            data['param_name']=[]
            for i in xrange(data['param_count']):
                data['param_name'].append(self.readU30()) #string
        return data

    def read_metadata(self):
        res_metadata=[]
        res_metadata_count = self.readU30()
        for i in xrange(res_metadata_count):
            metadata={}
            metadata['name']=self.readU30()
            metadata['item_count']=self.readU30()
            metadata['items']=[(self.readU30(),self.readU30()) for j in xrange(metadata['item_count'])]
            res_metadata.append(metadata)
        return res_metadata_count, res_metadata

    def read_instance(self):
        '''
        instance_info
        {
        u30 name
        u30 super_name
        u8 flags
        u30 protectedNs
        u30 intrf_count
        u30 interface[intrf_count]
        u30 iinit
        u30 trait_count
        traits_info trait[trait_count]
        }'''
        data={}
        data['name']=self.readU30() #multiname
        data['super_name']=self.readU30() #multiname
        data['flags']=self.readUI8()
        flags={'ClassSealed': 0x01,
               'ClassFinal': 0x02,
               'ClassInterface': 0x04,
               'ClassProtectedNs': 0x08,
               }
        if data['flags'] & flags['ClassProtectedNs']:
            data['protectedNs']=self.readU30() #namespace
        data['intrf_count']=self.readU30()
        data['interface']=[self.readU30() for i in xrange(data['intrf_count'])] #multiname
        self.read_class(data)
        return data

    def read_trait(self):
        '''
        traits_info
        {
        u30 name
        u8 kind
        u8 data[]
        u30 metadata_count
        u30 metadata[metadata_count]
        }'''
        data={}
        data['name']=self.readU30() #multiname
        data['kind']=self.readUI8()
        trait_type,trait_attrs = data['kind']&0x0f, data['kind']>>4
        trait_types={0:('Trait_Slot',lambda:[self.readU30(),self.readU30(),self.readU30(),self.readUI8()]),
                     1:('Trait_Method',lambda:[self.readU30(),self.readU30()]),
                     2:('Trait_Getter',lambda:[self.readU30(),self.readU30()]),
                     3:('Trait_Setter',lambda:[self.readU30(),self.readU30()]),
                     4:('Trait_Class',lambda:[self.readU30(),self.readU30()]),
                     5:('Trait_Function',lambda:[self.readU30(),self.readU30()]),
                     6:('Trait_Const',lambda:[self.readU30(),self.readU30(),self.readU30(),self.readUI8()])}
        data['data']=trait_types[trait_type][1]()
        attrs={'ATTR_Final': 0x1,
               'ATTR_Override': 0x2,
               'ATTR_Metadata': 0x4}
        if trait_attrs & attrs['ATTR_Metadata']:
            data['metadata_count'],data['metadata']=self.read_metadata()
        return data

    def read_class(self,data={}):
        '''
        class_info
        {
        u30 cinit
        u30 trait_count
        traits_info traits[trait_count]
        }'''
        data['init']=self.readU30() #method
        self.read_traits(data)
        return data

    def read_traits(self,data={}):
        data['trait_count']=self.readU30()
        data['trait']=[self.read_trait() for i in xrange(data['trait_count'])]
        return data

    def read_method_body(self):
        '''
        method_body_info
        {
        u30 method
        u30 max_stack
        u30 local_count
        u30 init_scope_depth
        u30 max_scope_depth
        u30 code_length
        u8 code[code_length]
        u30 exception_count
        exception_info exception[exception_count]
        u30 trait_count
        traits_info trait[trait_count]
        }'''
        fields=['method',
                'max_stack',
                'local_count',
                'init_scope_depth',
                'max_scope_depth',
                'code_length']
        data={field:self.readU30() for field in fields}
        data['code']=self.read_bytes(data['code_length'])
        data['exception_count']=self.readU30()
        data['exception']=[self.read_exception_info() for i in xrange(data['exception_count'])]
        self.read_traits(data)
        return data
        
    def read_exception_info(self):
        '''
        exception_info
        {
        u30 from
        u30 to
        u30 target
        u30 exc_type
        u30 var_name
        }'''
        fields=['from',
                'to',
                'target',
                'exc_type',
                'var_name']
        data={field:self.readU30() for field in fields}

class Namespace:
    def __init__(self,strings,kind,name):
        self.strings = strings
        self.kind = kind
        self.name = name
    @property
    def kinds(self):
        return {0x08:'Namespace',
                0x16:'PackageNamespace',
                0x17:'PackageInternalNs',
                0x18:'ProtectedNamespace',
                0x19:'ExplicitNamespace',
                0x1A:'StaticProtectedNs',
                0x05:'PrivateNs'}
#    @property
#    def name(self):
#        return self.kinds[self.kind]+'("'+self.strings[self.name]+'")'
    def __str__(self):
        return self.kinds[self.kind]+'('+self.strings[self.name]+')'

class Code_Reader(Reader):
    def __init__(self,code,strings,multinames):
        Reader.__init__(self)
        self.contents = code
        self.strings = strings
        self.multinames = multinames
        self.opcodes = {0xd1:('getlocal_1',[]),
                        0xd2:('getlocal_2',[]),
                        0xd6:('setlocal_2',[]),
                        0x85:('coerce_s',[]),
                        0x60:('getlex',['m']),
                        0x66:('getproperty',['m']),
                        0x2c:('pushstring',['s']),
                        0x42:('construct',['d']),
                        0x46:('callproperty',['m','d']),
                        0x24:('pushbyte',['u8']),
                        0xa0:('add',[]),
                        0xa3:('divide',[]),
                        0xa2:('multiply',[]),
                        0x48:('returnvalue',[]),
                        0x5d:('findpropstrict',['m'])
                        }
        self.args = {'m':lambda:self.multinames[self.readU30()],
                     'd':self.readU30,
                     's':lambda:self.strings[self.readU30()],
                     'u8':self.readUI8}
    def read(self):
        res=[]
        while self.pos < len(self.contents):
            opcode = self.readUI8()
            operation, args = self.opcodes[opcode]
            res.append(' '.join([operation]+[str(self.args[i]()) for i in args]))
        return res
    
class SWFParseError(Exception):
    pass
    
def swf2functions(data,postfix):
    swf=SWF(data)
    swf.read_header()
    swf.read_frames()
    abc=ABC(swf.find_ABC())
    #print abc.strings
    #print abc.multinames
    #print abc.methods
    #print self.method_body_count
    code=abc.method_body_info[1]['code']
    code_reader=Code_Reader(code,abc.strings,abc.multinames)
    read_code=code_reader.read()
    #print read_code
    read_code_str='\n'.join(read_code)
    #print read_code_str
    functions=[(['getlocal_1', 'coerce_s', 'setlocal_2'],
                lambda(x):x),
               (['getlocal_2',
                 'getlex QName(PackageNamespace(""),"loaderInfo")',
                 'getproperty QName(PackageNamespace(""),"loaderURL")',
                 'getlex QName(PackageNamespace(""),"RegExp")',
                 'pushstring "^.+\\/"',
                 'construct 1',
                 'callproperty QName(Namespace("http://adobe.com/AS3/2006/builtin"),"match") 1',
                 'pushbyte 0',
                 'getproperty MultinameL([PrivateNs(null),PackageNamespace(""),Namespace("http://adobe.com/AS3/2006/builtin"),PrivateNs(null),PackageInternalNs(""),ProtectedNamespace("SaltGenerator'+postfix+'"),StaticProtectedNs("SaltGenerator'+postfix+'"),StaticProtectedNs("flash.display:Sprite"),StaticProtectedNs("flash.display:DisplayObjectContainer"),StaticProtectedNs("flash.display:InteractiveObject"),StaticProtectedNs("flash.display:DisplayObject"),StaticProtectedNs("flash.events:EventDispatcher")])',
                 'getlex QName(PackageNamespace(""),"RegExp")',
                 'pushstring "^.*\\/\\/"',
                 'construct 1',
                 'pushstring ""',
                 'callproperty Multiname("replace",[PrivateNs(null),PackageNamespace(""),Namespace("http://adobe.com/AS3/2006/builtin"),PrivateNs(null),PackageInternalNs(""),ProtectedNamespace("SaltGenerator'+postfix+'"),StaticProtectedNs("SaltGenerator'+postfix+'"),StaticProtectedNs("flash.display:Sprite"),StaticProtectedNs("flash.display:DisplayObjectContainer"),StaticProtectedNs("flash.display:InteractiveObject"),StaticProtectedNs("flash.display:DisplayObject"),StaticProtectedNs("flash.events:EventDispatcher")]) 2',
                 'add', 'coerce_s', 'setlocal_2'],
                lambda(x):x+'s.shadowlands.ru/zombievk-res/'),
               (['getlocal_2',
                 'getlex QName(PackageNamespace(""),"RegExp")',
                 'pushstring "0"',
                 'pushstring "gi"',
                 'construct 2',
                 'pushstring "1"',
                 'callproperty QName(Namespace("http://adobe.com/AS3/2006/builtin"),"replace") 2',
                 'coerce_s','setlocal_2'],
                lambda(x):x.replace('0','1')),
               (['getlocal_2',
                 'callproperty QName(Namespace("http://adobe.com/AS3/2006/builtin"),"toLowerCase") 0',
                 'coerce_s', 'setlocal_2'],
                lambda(x):x.lower()),
               (['getlocal_2',
                 'callproperty QName(Namespace("http://adobe.com/AS3/2006/builtin"),"toUpperCase") 0',
                 'coerce_s', 'setlocal_2'],
                lambda(x):x.upper()),
               (['getlocal_2', 'coerce_s', 'setlocal_2'],
                lambda(x):x),
               (['getlocal_2',
                 'pushbyte 0',
                 'getlocal_2',
                 'getproperty QName(PackageNamespace(""),"length")',
                 'pushbyte 2',
                 'divide',
                 'callproperty QName(Namespace("http://adobe.com/AS3/2006/builtin"),"substring") 2',
                 'coerce_s', 'setlocal_2'],
                lambda(x):x[:len(x)/2]),
               (['findpropstrict QName(PackageNamespace(""),"String")',
                 'getlocal_2',
                 'getproperty QName(PackageNamespace(""),"length")',
                 'pushbyte 13',
                 'multiply',
                 'callproperty QName(PackageNamespace(""),"String") 1',
                 'coerce_s', 'setlocal_2'],
                lambda(x):str(len(x)*13)),
               (['getlocal_2', 'getlocal_2', 'add', 'coerce_s', 'setlocal_2'],
                lambda(x):x+x),
               (['getlocal_2',
                 'pushstring ""',
                 'callproperty QName(Namespace("http://adobe.com/AS3/2006/builtin"),"split") 1',
                 'callproperty QName(Namespace("http://adobe.com/AS3/2006/builtin"),"reverse") 0',
                 'pushstring ""',
                 'callproperty QName(Namespace("http://adobe.com/AS3/2006/builtin"),"join") 1',
                 'coerce_s', 'setlocal_2'],
                lambda(x):''.join(reversed(list(x))))
               ]
    fns=[]
    fnums=[]
    while read_code_str != 'getlocal_2\nreturnvalue':
        for i,(strs,f) in enumerate(functions):
            start_str = '\n'.join(strs)
            if read_code_str.startswith(start_str):
                fns.append(f)
                fnums.append(i)
                read_code_str = read_code_str[len(start_str+'\n'):]
                break
        else:
            with open('salt'+postfix+'.swf','wb') as f:
                f.write(swf.original)
                #print fnums
            raise SWFParseError('Something\'s wrong, please send the swf to the author')
            break
    else:
        return fns[1:]
'''
(C) 2014 megabyte
''' 


[doubleaggent]

Цитата: Сообщение от zloy_gnom_2012 давно уже есть решение проблемы более простым методом)

благодарю за столь быстрый ответ спасибо все работает!!

У меня еще такой вопрос, не подскажите хоть примерно где искать активацию супер урожая, а то она мне не нужна на данный момент а активация осуществляется автоматически

[DarkLost]

Народ поделитесь багом на золиан,пожалуйста.

[3HtSCtBGcBOf]

а чем вас этот бот не устраивает?
[Ссылки могут видеть только зарегистрированные пользователи. ]

[Cheater-84]

Цитата: Сообщение от 3HtSCtBGcBOf а чем вас этот бот не устраивает? [Ссылки могут видеть только зарегистрированные пользователи. ]

привет, для начала его нельзя под себя написать.....что то подправить так, как нужно именно тебе, что то добавить свое, а не постоянно бегать к нашему уважаемому автору и писать - добавь это, добавь то и так далее и тому подобное. хотя я может не прав, надеюсь кто то допишет мою мысль)

[3HtSCtBGcBOf]

понятно,но в основном то бот полностью функционален,все что необходимо бот делает,а по поводу бегать или нет,думаю можно собрать список пожеланий и отправить автору!Лично меня этот бот полностью устраивает,если бы я конечно и соображал в программировании,то возможно согласился бы с Вами)

[Shurup240]

Ребят! На фейсбуке кто-то запустил бота?
Решил свалить из Вконтактика

[doubleaggent]

Цитата: Сообщение от 3HtSCtBGcBOf понятно,но в основном то бот полностью функционален,все что необходимо бот делает,а по поводу бегать или нет,думаю можно собрать список пожеланий и отправить автору!Лично меня этот бот полностью устраивает,если бы я конечно и соображал в программировании,то возможно согласился бы с Вами)

Согласен, функционал не плохой у него, но вот лично я не пользуюсь им так-как он платный, а платить каждый месяц хоть и не большую цену у меня нет желания, так-как есть и бесплатные боты с почти таким же функционалом, да и это все го лишь игра и вложения в неё не имеют смысла

[zloy_gnom_2012]

Цитата: Сообщение от 3HtSCtBGcBOf а чем вас этот бот не устраивает? [Ссылки могут видеть только зарегистрированные пользователи. ]

хотя бы только тем что автор почти не заходит в тему с ботом))