def getSettings(self): import db mongo = db.mongoAdapter() settings_raw = mongo.find('settings') self.classes = {} self.priority_stats = {} self.available_weapons = {} self.starter_equip = {} self.damage_type = {} self.classes_stats = {} self.classes_and_races = {} artworks = mongo.getu('artworks', {'default': 1}, {'_id': 1, 'img':1, 'faction':1, 'race':1, 'class':1}) self.default_artworks = {} for artwork in artworks: self.default_artworks.update({ str(artwork['faction'])+str(artwork['race'])+str(artwork['class']): { 'src': artwork['img'], '_id': artwork['_id'] } }) if settings_raw: for class_id in settings_raw['classes']: item = settings_raw['classes'][class_id] self.classes.update({class_id: item['name']}) self.priority_stats.update({class_id: item['priority_stat']}) self.available_weapons.update({class_id: item['available_weapons'].split(';')}) self.starter_equip.update({class_id: map(int, item['starter_equip'].split(';'))}) self.damage_type.update({class_id: item['damage_type']}) self.classes_stats.update({class_id: settings_raw['classes_stats'][class_id]}) self.classes_and_races = self.getClassesAndRaces()
class MentionsNotifications: mongo = db.mongoAdapter() balance = settings.balance() core = settings.core() p_key = core.p_parser_key p_secret = core.p_parser_secret def __init__(self): print 'Loaded ' + str(len(self.core.loaded_data['bots'])) + ' bots:' for bot in self.core.loaded_data['bots']: print '> @' + bot['name'] print self.setBot(0) def setBot(self, bot_id): self.bot_id = bot_id self.bot = self.core.loaded_data['bots'][bot_id] def postNotification(self, notification): try: auth = tweepy.OAuthHandler(self.p_key, self.p_secret) auth.set_access_token(self.bot['token1'].decode('utf-8'), self.bot['token2'].decode('utf-8')) api = tweepy.API(auth) api.update_status(notification) except Exception, e: print 'Error post', notification['name'], e
class statistics(): mongo = db.mongoAdapter() dungeons_count = mongo.count('dungeons') player_stat_col = 'statistics' base_stat_col = 'statistics_static' stats_array = {} updated_records = Set() def __init__(self): pass def update(self, data, params): changed = False if params: for param in params: if param in data['stats']: if param == 'lvl': data['stats'][param] = params[param] else: data['stats'][param] += params[param] changed = True return changed
def readMap(mapname): lines = [] with codecs.open(mapname, "r", "utf-16") as sourceFile: while True: contents = sourceFile.readline() if not contents: break lines.append(contents) mongo = db.mongoAdapter() mongo.cleanUp('map') width = 60 #filelines[0].split(',')[0][2:] height = 50 #filelines[0].split(',')[1] RE_MAP_KEY = re.compile('end-map-key') state = 0 x = 0 y = 0 line_number = 0 features = [] for line in lines: if state == 0: if re.search(RE_MAP_KEY,line): state = 1 elif state == 1: state = 2 elif state == 2: if x == height and y < width: x = 0 y += 1 if y < width: buff = line.split('\t') if buff[0] == 'feature': type_of_object = buff[3].split(':')[1] features.append({'y':x-1, 'x':y, 'type': type_of_object}) else: data = {'y':x, 'x':y, 'tile': buff[0], 'elevation': int(buff[1].split(':')[1]) } x += 1 mongo.insert('map', data) line_number += 1
class adminControl(): mongo = db.mongoAdapter() def __init__(self): pass def setAdmin(self, player_name): self.mongo.update('players', {'name': player_name}, {'admin': True}) def unsetAdmin(self, player_name): self.mongo.raw_update('players', {'name': player_name}, {'$unset': { 'admin': 1 }})
def getMap(self): import db mongo = db.mongoAdapter() coords_array = mongo.getu('map', sort={'y': 1, 'x': 1}) map = [[]] x = 0 y = 0 for item in coords_array: if x < self.MAP_WIDTH: pass else: map.append([]) x = 0 y += 1 map[y].append([item['tile'],item['elevation']]) x += 1
def getMap(self): import db mongo = db.mongoAdapter() coords_array = mongo.getu('map', sort={'y': 1, 'x': 1}) map = [[]] x = 0 y = 0 for item in coords_array: if x < self.MAP_WIDTH: pass else: map.append([]) x = 0 y += 1 map[y].append([item['tile'], item['elevation']]) x += 1
class achievements(): mongo = db.mongoAdapter() updated_records = Set() player_achv_col = 'achievements' base_achv_col = 'achievements_static' static = [] achvs_array = {} def __init__(self, load_static = True): if load_static: self.static = self.loadStatic() def loadStatic(self): return self.mongo.getu(self.base_achv_col, {'type': { '$gt': 0 }}, fields={ "condition": 1, "UID": 1 }) def update(self, data, statistic): new_achvs = Set() for achv in self.static: if not data['achvs'][str(achv['UID'])]: earn_it = True for condition in achv['condition']: if condition in statistic['stats']: earn_it = earn_it and (statistic['stats'][condition] >= achv['condition'][condition]) else: earn_it = False if earn_it: data['achvs'][str(achv['UID'])] = True new_achvs.add(achv['UID']) return new_achvs
def __init__(self): self.mongo = db.mongoAdapter() self.players = ModelPlayers(self.mongo) self.playerInstance = PlayerInstance self.items = ModelItems(self.mongo) self.crafted_item = CraftedItemInstance self.game_item = Item self.spells = ModelSpells(self.mongo) self.craftedSpellPattern = CraftedSpellPattern self.spellbook = SpellBook self.event = Event self.events = ModelEvents(self.mongo) self.guild = Guild self.guilds = ModelGuilds(self.mongo) self.sa = ModelSA(self.mongo) self.misc = ModelMisc(self.mongo) self.artwork = Artwork
class artistsRatingsCounter: mongo = db.mongoAdapter() balance = settings.balance() core = settings.core() def countRatings(self): starttime = time.time() authors = {} likes = self.mongo.getu('items_likes', {'author_id': {'$exists': True}}) for like in likes: author_str_id = str(like['author_id']) if not author_str_id in authors: authors.update({author_str_id: 0}) authors[author_str_id] += len(like['people']) self.mongo.cleanUp('authors_likes') for author_str_id in authors: author_info = self.mongo.find('players', {'_id': ObjectId(author_str_id)}, {'_id': 1, 'name': 1, 'avatar': 1}) if author_info: self.mongo.insert('authors_likes', { 'author_id': author_info['_id'], 'author_name': author_info['name'], 'author_avatar': author_info['avatar'], 'likes': authors[author_str_id] }) message = 'Artist ratings was counted by '+str(time.time()-starttime)+' seconds' print message
class cacheController(): collection = 'cache' mongo = db.mongoAdapter() mc = memcache.Client(['127.0.0.1:11211'], debug=1) core = __main__.tweenk_core exclude = ['new', 'login', 'registration', 'logout', 'admin'] def __init__(self): pass def cleanCache(self): self.mc.flush_all() def isPlayer(self): cookie = cherrypy.request.cookie is_player = 'user_id' in cookie.keys() and 'hash' in cookie.keys() return is_player def cacheLoad(self, page_name, params=[]): if page_name in self.exclude: return False try: key = '|'.join([page_name, '#'.join(params)]) cache = self.mc.get(key.encode('utf-8')) if cache: if time.time() - int(cache['time']) < self.core.CACHE_TIME: return cache except Exception: print 'Can not load cache', page_name return False def deleteCache(self, page_name, player, params={}): try: mobile = self.isMobile() key = '|'.join([page_name, player, '#'.join(params), mobile]) self.mc.delete(key.encode('utf-8')) except: print 'Can not delete cache', page_name def cacheSave(self, page_name, params={}, content=''): if page_name in self.exclude: return False print 'saving...' try: key = '|'.join([page_name, '#'.join(params)]) obj = {'content': content, 'time': time.time()} self.mc.set(key.encode('utf-8'), obj) return True except Exception: print 'Can not save cache', page_name return False def permanentSave(self, page_name, params={}, content=''): self.cacheSave(page_name, params, content) def permanentLoad(self, page_name, params=[]): try: key = '|'.join([page_name, '_', '#'.join(params), '_']) cache = self.mc.get(key.encode('utf-8')) if cache: return cache except Exception: print 'Can not load cache', page_name return False def tmpLoad(self, tmp_name): try: cache = self.mc.get(tmp_name.encode('utf-8')) if cache: if time.time() - int(cache['time']) < self.core.TMP_CACHE_TIME: return cache except: print 'Can load template cache', tmp_name return False def tmpSave(self, tmp_name, content): try: self.mc.set(tmp_name.encode('utf-8'), { 'content': content, 'time': time.time() }) except: print 'Can not save template cache', tmp_name
class serviceCatcher(): core_settings = settings.core() data = settings.balance() log = logger.logger() LOG_NAME = os.path.abspath( os.path.split(inspect.getfile( inspect.currentframe()))[0]) + '/logs/newparser.log' LOCK_NAME = os.path.abspath( os.path.split(inspect.getfile( inspect.currentframe()))[0]) + '/__lock__' timelines = {} p_key = core_settings.p_parser_key p_secret = core_settings.p_parser_secret mongo = db.mongoAdapter() queue = myQueue() local_queue = myQueue() missing_players = [] auths = {} apis = {} threads = {} threads_number = 0 request_time = 0 parse_time = 0 group_number = 0 graph_tweets = {} def __init__(self): self.parser = tweet_parser.tweetParser(debug=False) def _createLock(self): fp = open(self.LOCK_NAME, 'w') fp.write('YEAH') fp.close() def loadDataToQueue(self, array=False): self.queue = myQueue() self.queue.body = [] if not array: buff_players = self.mongo.getu( 'players', search={ 'banned': { '$exists': False }, 'last_login': { '$gte': time.time() - self.core_settings.MAX_TIME_TO_SLEEP } }, fields={ 'user_id': 1, 'name': 1, 'token1': 1, 'token2': 1 }, sort={'last_login': -1}) else: buff_players = array self.queue.add(buff_players) def startThread(self, name): self.threads.update({name: ThreadWithExc(self, name)}) self.threads[name].start() def startPostThread(self, name): self.threads.update({name: ThreadPostNotification(self, name)}) self.threads[name].start() def getTimelineFromTwitter(self, user): try: self.auths[user['user_id']] = tweepy.OAuthHandler( self.p_key, self.p_secret) self.auths[user['user_id']].set_access_token( user['token1'], user['token2']) self.apis[user['user_id']] = tweepy.API( self.auths[user['user_id']]) timeline = self.apis[user['user_id']].user_timeline( include_entities=1, include_rts=True) except Exception, e: timeline = False print 'Error', user['name'], e try: del self.auths[user['user_id']] del self.apis[user['user_id']] except Exception: pass return timeline
class Informer(): spell_types = ['', '+', '', '-'] core = __main__.tweenk_core data = __main__.tweenk_balance mongo = db.mongoAdapter() def __init__(self): pass def getItemInfo(self, item_uid, can_use=0, suffix_uid=0): try: item = self.mongo.find('items', {'UID': int(item_uid)}) player_item = False except Exception: item = self.mongo.find('items_created', {'_id': ObjectId(item_uid)}) player_item = True if not item: return 'In Soviet Russia items pickup you!' if not player_item: img = './data/items/' + str(item['img']) + '.jpg' custom_class = '' else: img = item['img'] + '_fit.png' custom_class = 'class="player_item"' response = "<img src='" + img + "'><c " + custom_class + "><n" + str( int(item['color'])) + ">" + item['name'] + "</n" + str( item['color']) + ">" try: if can_use == '0': response += "<t class='item-cant-use'>" else: response += "<t>" if int(item['type']) != 1: response += self.data.item_types[int(item['type'])] else: response += item['view'].title() response += ', Level ' + str(item['lvl_min']) + "</t>" except: pass if 'DMG' in item['bonus'] and item['bonus']['DMG'] > 0: response += "<dmg>" + self.data.stats_name['DMG'] + " " + str( int(item['bonus']['DMG']) - 1) + "-" + str(int(item['bonus']['DMG']) + 1) + "</dmg>" if 'DEF' in item['bonus'] and item['bonus']['DEF'] > 0: response += "<def>" + self.data.stats_name['DEF'] + " " + str( int(item['bonus']['DEF'])) + "</def>" for stat in ['int', 'str', 'dex', 'luck', 'HP', 'MP']: if stat in item['bonus'] and item['bonus'][stat] != 0: response += "<s>" "+" + str( int(item['bonus'] [stat])) + " " + self.data.stats_name[stat] + "</s>" response += "</c><div class='clear'></div>" return response def getTriviaItemsInfo(self, item_uid): item = self.mongo.find('shop_items', {'item_UID': int(item_uid)}) if not item: return 'In Soviet Russia items pickup you!' result = "<img src='/data/items/non_combat/" + item[ 'img'] + ".jpg?" + __main__.tweenk_core.__version__ + "'>" result += "<c class='player_item'><n0>" + item['name'] + "</n0>" if item['desc'] == '0': result += '<t>Description is empty. Write to us about this item!</t>' else: result += "<span class='trivia-desc'>" + item['desc'] + "</span>" if item['author'] != '0': result += "<span class='trivia-author'> Description by " + item[ 'author'] + "</span>" result += "</c><br class='clear'/>" return result def getMonsterInfo(self, uid): monster = self.mongo.find('monsters', {'UID': int(uid)}, { 'name': 1, 'lvl_min': 1, 'boss': 1, 'area': 1, 'class': 1, 'dungeon': 1 }) if not monster: return 'In Soviet Russia monster kills you!' response = '<c class="noimg"><n>' + monster['name'] + '</n>' response += '<def>Level ' + str(monster['lvl_min']) + '</def>' if len(monster['class']) > 3: response += '<s>' + monster['class'] + '</s>' if monster['boss']: dungeon = self.mongo.find('dungeons', {'UID': monster['dungeon']}) response += '<s>Boss in ' + dungeon['name'] + '</s>' elif monster['area']['area_dungeon']: dungeon = self.mongo.find('dungeons', {'UID': monster['dungeon']}) response += '<s>Monster in ' + dungeon['name'] + '</s>' response += "</c>" return response def getDungeonInfo(self, uid): dungeon = self.mongo.find('dungeons', {'UID': int(uid)}, { 'name': 1, 'lvl_min': 1, 'lvl_max': 1 }) if not dungeon: return 'In Soviet Russia dungeon runs you!' response = '<c class="noimg"><n>' + dungeon['name'] + '</n>' response += '<def>Level ' + str( dungeon['lvl_min']) + ' — ' + str( dungeon['lvl_max']) + '</def>' #response += '<s>'+dungeon['desc']+'</s>' response += "</c>" return response def getShopItemInfo(self, type_id, uid): item = self.mongo.findOne('shop_items', {'UID': int(uid)}) if not item: return 'In Soviet Russia shop buys you!' response = "<img src='./data/items/non_combat/" + str( item['img']) + ".jpg'><c><n>" + item['name'] + '</n>' response += '<def>' + str(item['desc']) + '</def>' if 'bonus' in item: for stat in ['int', 'str', 'dex', 'luck', 'HP', 'MP']: if item['bonus'][stat] != 0: response += "<s>" "+" + str( int(item['bonus'] [stat])) + " " + self.data.stats[stat] + "</s>" response += "</c>" return response def getBGInfo(self, uid): battleground = self.mongo.find('battlegrounds', 'UID', int(uid)) if not battleground: return 'In Soviet Russia battleground runs you!' response = '<c class="noimg"><n>' + battleground['name'] + '</n>' response += '<def>Level ' + str( battleground['lvl_min']) + ' — ' + str( battleground['lvl_max']) + '</def>' #response += '<s>'+dungeon['desc']+'</s>' response += "</c>" return response def getSpellInfo(self, uid): spell = self.mongo.find('spells', {'_id': ObjectId(uid)}) if not spell: spell = self.mongo.find('spells_created', {'_id': ObjectId(uid)}) else: spell['img'] = './data/spells/' + spell['img'] + '.jpg' if not spell: return 'In Soviet Russia spells cast you!' result = "<img src='" + spell['img'] + "' width='54'>" result += "<c class='player_item'><n0>" + spell['name'] + "</n0>" result += "<t>" + spell['keyword'] + "</t><br><s>" for action in spell['spell_actions']: result += self.spell_types[action['type']] + str( action['value']) + self.data.stats_name[ action['effect']] + '<br>' result += "</s></c><div class='clear'></div>" return result # Deprecated def getUserInfo(self, nickname): pass def getAchvInfo(self, uid): achv = self.mongo.find('achievements_static', {'UID': int(uid)}) if not achv: return 'In Soviet Russia achievement earns you!' return "<img src='" + self.core.IMAGE_ACHV_FOLDER + achv[ 'img'] + ".jpg'><c><n0>" + achv['name'] + "</n0><s>" + achv[ 'text'] + "</s></c>" def getInfo(self, obj, main_uid, prefix_uid=0, suffix_uid=0): obj_type = int(obj) result = '' if obj_type == 1: result = self.getItemInfo(main_uid, prefix_uid, suffix_uid) elif obj_type == 2: result = self.getMonsterInfo(main_uid) elif obj_type == 3: result = self.getDungeonInfo(main_uid) elif obj_type == 4: result = self.getUserInfo(main_uid) elif obj_type == 5: result = self.getAchvInfo(main_uid) elif obj_type == 6: result = self.getBGInfo(main_uid) elif obj_type == 7: result = self.getShopItemInfo(main_uid, prefix_uid) elif obj_type == 8: result = self.getTriviaItemsInfo(main_uid) elif obj_type == 9: result = self.getDungeonInfo(main_uid) elif obj_type == 10: result = self.getSpellInfo(main_uid) return result
def mongoConnect(self): try: self.mongo except: self.mongo = db.mongoAdapter()
class builder(): cur_time = datetime.datetime.now() loads = 0 mongo = db.mongoAdapter() cache = memcache_controller.cacheController() env = Environment( auto_reload=True, loader=FileSystemLoader(__main__.tweenk_core.APP_DIR+'templates/') ) # print len(env.list_templates('.jinja2')),'templates loaded' env.filters['plural'] = plural env.filters['pluralEnd'] = pluralEnd env.filters['datetime'] = format_datetime env.filters['summAr'] = summAr def __init__(self, core = None, balance = None): if not core: core = __main__.tweenk_core balance = __main__.tweenk_balance self.balance = balance self.core_settings = core self.base_fields = self.core_settings.base_fields self.precompileRegexps() def precompileRegexps(self): self.RE_if = re.compile("((\{if\s([^\}]*)\})(((?!\{if\s([^\}]*)\}).)*?)(\{endif\}))", re.S+re.M) self.RE_vars = re.compile("(\{([^\}]*)\})") self.RE_for = re.compile("(\{for\s([^\}]*)\}(.*?)\{endfor\})",re.S+re.M) self.RE_load = re.compile("(\{load\:([^\}]*)\})") self.RE_comments = re.compile("(\{\*.*?\*\})",re.S+re.M) self.RE_mobile = re.compile("(android|iphone)", re.I) def isMobileDevice(self): if self.core_settings.debug['mobile_debug']: return True return re.search(self.RE_mobile, cherrypy.request.headers.get('user-agent', '')) def setCookie(self, params, age = 604800): cookie = cherrypy.response.cookie for item in params: cookie[item] = params[item] cookie[item]['path'] = '/' cookie[item]['max-age'] = age cookie[item]['version'] = 1 def getOneCookie(self, cookie_name): cookie = cherrypy.request.cookie if cookie_name in cookie.keys(): return cookie[cookie_name].value else: return False def deleteCookie(self, name): self.setCookie({name:''},0) def getCookie(self): cookie = cherrypy.request.cookie if 'hash' in cookie.keys() and 'user_id' in cookie.keys(): return { 'hash':cookie['hash'].value, 'user_id': int(cookie['user_id'].value), 'just_login': '******' in cookie.keys() } def getLoginCookie(self): cookie = cherrypy.request.cookie if 'login' in cookie.keys(): return cookie['login'].value def playerLogged(self): def updateUserInfo(player): p_key = self.core_settings.p_key p_secret = self.core_settings.p_secret auth = tweepy.OAuthHandler(p_key, p_secret) auth.set_access_token(player['token1'], player['token2']) api = tweepy.API(auth) user = api.me() if user.utc_offset: utc_offset = user.utc_offset else: utc_offset = 0 data = { 'avatar': user.profile_image_url, 'utc_offset': utc_offset, 'name': user.screen_name, } updated = {} for key in data: if data[key] != player[key]: updated.update({key: data[key]}) if updated: player.update(updated) self.mongo.raw_update('players', {'_id': player['_id']}, {'$set': updated}) return data cookie = self.getCookie() if cookie or self.core_settings.always_login: if cookie: query = {'user_id':int(cookie['user_id'])} else: query = {'name': self.core_settings.login_name} query.update({'banned': {'$exists': 0}}) player = self.mongo.find('players', query, { 'name': 1, 'avatar': 1, 'lvl': 1, '_id': 1, 'user_id': 1, 'last_login': 1, 'session_hash': 1, 'admin': 1, 'resources':1, 'faction': 1, 'race':1, 'token1':1, 'token2':1, 'class':1, '_guild_name': 1, 'moderator':1, 'utc_offset':1, 'ugc_disabled':1, 'ugc_enabled':1 }) if not cookie and player: cookie = {'hash': player['session_hash'],'user_id':player['user_id']} if player: if 'session_hash' in player: if player['session_hash'] == cookie['hash']: if 'just_login' in cookie and cookie['just_login']: try: updateUserInfo(player) except Exception: pass if 'utc_offset' in player and player['utc_offset']: utc_offset = player['utc_offset'] else: utc_offset = 0 result_hash = { 'login_name' : player['name'], 'login_avatar' : player['avatar'], 'login_lvl' : player['lvl'], 'login_id' : player['_id'], 'login_user_id' : player['user_id'], 'login_faction' : player['faction'], 'login_resources': player['resources'], 'login_race': player['race'], 'login_class': player['class'], 'login_race_str': self.balance.races[int(player['faction'])][int(player['race'])], 'login_class_str': self.balance.classes[str(player['class'])], 'login': True, 'login_utc_offset': utc_offset, 'login_ugc_disabled': 'ugc_disabled' in player and player['ugc_disabled'], 'login_ugc_enabled': 'ugc_enabled' in player and player['ugc_enabled'] } if 'admin' in player and player['admin']: result_hash.update({'login_admin': True}) elif 'moderator' in player and player['moderator']: result_hash.update({'login_moderator': True}) if '_guild_name' in player and player['_guild_name']: guild_name = player['_guild_name'] else: guild_name = '' result_hash.update({'login_guild': guild_name}) if 'last_login' in player and player['last_login']>(time.time()-self.core_settings.LAST_LOGIN_TIMEOUT): pass else: self.mongo.update('players', {'user_id':int(cookie['user_id'])}, {'last_login': time.time()}) if 'last_login' in player and player['last_login'] > time.time() - self.core_settings.MAX_TIME_TO_SLEEP: pass else: message = self.balance.wakeup_message message['time'] = time.time() self.mongo.raw_update('messages_created', {'user_id': player['user_id']}, { '$push': {'last': message} }) return result_hash return False def createSession(self, user_id): auth_hash = self.core_settings.getAuthHash(user_id) self.setCookie({'user_id': user_id, 'hash': auth_hash}) self.mongo.update('players',{'user_id':user_id},{'session_hash':auth_hash}) def throwWebError(self, error_code = 404, params = {}): # Метод обработки ошибок error = 'Unknown error' if error_code == 404: error = 'Page Not Found' elif error_code == 1001: error = 'Admin auth required' elif error_code == 1002: error = 'You must <a href="/login">login</a> to see this page ' elif error_code == 2001: if 'invites' in self.core_settings.debug and self.core_settings.debug['invites']: self.httpRedirect(self.core_settings.loaded_data['site_address']) error = 'Auth Failed' elif error_code == 3001: error = 'No rights to edit this' elif error_code == 4001: error = 'Can\'t join to this event. ' if params: error += params # item errors elif error_code == 5001: if params: error = params+' not found' else: error = 'Thing not found' elif error_code == 5002: if params: error = 'This '+params+' was rejected' else: error = 'This thing was rejected' elif error_code == 5003: if params: error = 'This '+params+' is waiting for approve' else: error = 'This thing is waiting for approve' elif error_code == 5004: error = 'Message not found!' # lvl < elif error_code == 6001: error = 'Your level is too low to create new things' elif error_code == 7001: error = 'Player not found' fields = {'error': error, 'code':error_code } return self.loadTemplate('error.jinja2', fields) def redirect(self, url, text = "Redirecting ... "): fields = {'redirect_url':url,'redirect_text':text} return self.loadTemplate('redirect.jinja2',fields) def httpRedirect(self, url): raise cherrypy.HTTPRedirect(url) def parseLogin(self, fields = None, param = None): auth = tweepy.OAuthHandler(self.core_settings.p_key, self.core_settings.p_secret) url = auth.get_authorization_url(True) self.setCookie({'login':'******'}, 20) return self.redirect(url) def parseLogout(self, fields = None, param = None): self.deleteCookie('hash') return self.redirect('index') def getMobileTemplates(self): re_TMP = re.compile('tmp$') mobile_templates = [] self.mobile_templates = [] for dirname, dirnames, filenames in os.walk(self.core_settings.MOBILE_TEMPLATES_FOLDER): for filename in filenames: if re.search(re_TMP, filename): buff = os.path.join(dirname, filename) buff = buff.replace(self.core_settings.MOBILE_TEMPLATES_FOLDER,'') mobile_templates.append(buff) self.mobile_templates = mobile_templates def findMobileTemplate(self, tmp_name): for tmp in self.mobile_templates: if tmp == tmp_name: return True return False def prettifyTmpPath(self, tmp_path): return tmp_path.replace('./','') def loadTextFromFilename(self, filename): # для мобильной версии отдельные шаблоны fileExt = "" filename = self.prettifyTmpPath(filename) abspath = os.path.abspath(os.path.split(inspect.getfile( inspect.currentframe() ))[0])+'/../' fileAr = os.path.splitext(filename) if (fileAr[1] != ".jinja2"): filename+=".tmp" if self.isMobileDevice() and self.findMobileTemplate(filename): filename = abspath+self.core_settings.MOBILE_TEMPLATES_FOLDER+filename else: filename = abspath+self.core_settings.TEMPLATES_FOLDER+filename try: cache_tmp = self.cache.tmpLoad(filename) except Exception: cache_tmp = False if cache_tmp: text = cache_tmp['content'] else: fp = open(filename,'r') text = fp.read() if not re.match('(\{|\<)',text[:3]): text = text[3:] try: self.cache.tmpSave(filename, text) except Exception: pass return text def loadTemplate(self, filename = '', fields = {}, incoming_text = False, useJ = False): if not 'current_page' in fields: fields.update({ 'current_page': filename, 'version': self.core_settings.__version__, 'address': cherrypy.request.path_info[1:], 'build': self.core_settings.__build__, 'conf_name': self.core_settings.loaded_data['conf_name'] }) if not 'login' in fields: fields.update({'login':False}) fields.update(self.base_fields) template = self.env.get_template(filename) fields.update({"fields": fields}) text = template.render(fields) return text
class ratingsCounter: K1 = 0.02 K2 = 1.5 K_kill = 100 RD = 25 mongo = db.mongoAdapter() balance = settings.balance() core = settings.core() log = logger.logger('logs/system_events.log') def __init__(self): pass def countUserRatings(self): def countTheUserRating(sort_field, result_field): self.players.sort(key=lambda x: x[sort_field]) self.players.reverse() place = 1 for player in self.players: if 'banned' in player and player['banned']: player.update({result_field: 100500}) else: player.update({result_field: place}) place += 1 starttime = time.time() for player in self.players: # Умножаем уровень на 100 млн и прибавляем опыт # чтобы два раза не сравнивать (по уровню и по опыту) # а учитывать общее значение player.update( {'rating': player['lvl'] * 100000000 + player['exp']}) # Если нет информации о том сколько твитов игрока за день получено # то считаем 0 if not 'today_parsed_tweets' in player: player.update({'today_parsed_tweets': 0}) # Если нет информации о том сколько pvp points игрок за день набрал # то считаем что все (что вчера у него было 0 очков) if not 'prev_day_pvp' in player: player.update({'pvp_per_day': player['pvp_score']}) else: player.update({ 'pvp_per_day': player['pvp_score'] - player['prev_day_pvp'] }) # Считаем рейтинг игрока по метрикам global_metric = 0 if player['lvl'] == 1: global_metric = 0 else: if 'metrics' in player: if 'monster_kill' in player['metrics']: for hour in player['metrics']['monster_kill']: global_metric += ( self.balance.max_lvl - player['metrics']['monster_kill'][hour]['lvl'] * self.K2) * self.K1 * self.K_kill * player[ 'metrics']['monster_kill'][hour]['value'] else: global_metric = 0 try: if player['ratings']['trending_position'] <= 10: if player['ratings']['trending_position'] <= 3: global_metric = global_metric * 0.7 elif player['ratings']['trending_position'] <= 7: global_metric = global_metric * 0.8 else: global_metric = global_metric * 0.9 except Exception: pass global_metric = global_metric + global_metric / 100 * random.randint( 0, self.RD) player.update({'trending_score': global_metric}) # Считаем место игрока в глобальном рейтинге игроков по опыту, # Если уровень одинаковый, то выше в рейтинге тот, у кого больше опыта countTheUserRating('rating', 'rating_by_exp') # ... в общем рейтинге игроков по pvp points countTheUserRating('pvp_score', 'rating_by_pvp') # ... в общем рейтинге игроков по achv_points countTheUserRating('achv_points', 'rating_by_achv_points') # ... trending players countTheUserRating('trending_score', 'trending_position') for player in self.players: record = { 'rating_by_exp': player['rating_by_exp'], 'rating_by_pvp': player['rating_by_pvp'], 'rating_by_achv_points': player['rating_by_achv_points'], 'trending_position': player['trending_position'], 'trending_score': player['trending_score'] } self.mongo.update('players', {'_id': player['_id']}, {'ratings': record}) message = 'Player ratings was counted by ' + str( time.time() - starttime) + ' seconds' self.log.write(message) print message def countGuildRatings(self): def countGuildRating(field): self.guilds.sort(key=lambda x: x[field]) self.guilds.reverse() place = 1 for guild in self.guilds: guild.update({field: place}) place += 1 starttime = time.time() for guild in self.guilds: guild.update({ 'buff_global_metric': 0, 'buff_rating': 0, 'buff_pvp': 0, 'pvp_score': 0, }) query = [] for id in guild['people']: query.append({'_id': id}) members = self.mongo.getu('players', search={'$or': query}, fields={ 'lvl': 1, 'pvp_score': 1, 'ratings': 1 }) for player in members: try: guild['buff_global_metric'] += player['ratings'][ 'trending_score'] guild['buff_rating'] += player['lvl'] guild['buff_pvp'] += player['pvp_score'] except Exception: pass if len(members) < 5: guild['buff_global_metric'] = 0 guild['pvp_score'] = int(guild['buff_pvp']) # Считает место гильдии в глобальном рейтинге гильдии # по сумме уровня членов гильдии countGuildRating('buff_rating') # ... sum trending members countGuildRating('buff_global_metric') # .. по общему pvp_score участников countGuildRating('buff_pvp') for guild in self.guilds: record = { 'rating_place_members_lvl': guild['buff_rating'], 'rating_place_members_pvp': guild['buff_pvp'], 'trending_position': guild['buff_global_metric'], 'pvp_score': guild['pvp_score'] } self.mongo.update('guilds', {'_id': guild['_id']}, {'ratings': record}) message = 'Guilds ratings was counted by ' + str( time.time() - starttime) + ' seconds' self.log.write(message) print message def countAll(self): self.players = self.mongo.getu('players', {'banned': { '$exists': False }}, { '_id': 1, 'lvl': 1, 'exp': 1, 'achv_points': 1, 'pvp_score': 1, 'metrics': 1, 'ratings': 1 }) self.banned_players = self.mongo.getu('players', {'banned': { '$exists': True }}, { '_id': 1, 'lvl': 1, 'exp': 1, 'achv_points': 1, 'pvp_score': 1, 'metrics': 1 }) self.guilds = self.mongo.getu('guilds', {}, { 'id': 1, 'name': 1, 'people': 1 }) self.countUserRatings() self.countGuildRatings() for player in self.banned_players: record = { 'rating_by_exp': 100500, 'rating_by_pvp': 100500, 'rating_by_achv_points': 100500, 'trending_position': 100500, 'trending_score': 0 } self.mongo.update('players', {'_id': player['_id']}, record) self.exit() def countGameStatistics(self): count_players = [] for index in range(0, len(self.balance.faction)): query = {'faction': index, '$or': [{'race': 0}, {'race': 1}]} count_players.append(self.mongo.count('players', query)) count_avg_level = [0, 0, 0] players = self.mongo.getu('players', {}, {'lvl': 1, 'faction': 1}) for player in players: count_avg_level[player['faction']] += player['lvl'] for index in range(0, len(self.balance.faction)): try: count_avg_level[index] = float( int( float(count_avg_level[index]) / count_players[index] * 10)) / 10 except Exception: count_avg_level[index] = 0.0 current_time = time.localtime() hashkey = str(current_time.tm_year) + str(current_time.tm_yday) lastday_stat = self.mongo.find('game_statistics', {'type': 'lastday_avg_level'}) if not lastday_stat or time.localtime( ).tm_hour > 20 and not lastday_stat['hashkey'] == hashkey: self.mongo.update('game_statistics', {'type': 'lastday_avg_level'}, { 'type': 'lastday_avg_level', 'data': count_avg_level, 'hashkey': hashkey }, True) self.mongo.update('game_statistics', {'type': 'lastday_count'}, { 'type': 'lastday_count', 'data': count_players, 'hashkey': hashkey }, True) self.mongo.update('game_statistics', {'type': 'players_count'}, { 'type': 'players_count', 'data': count_players }, True) self.mongo.update('game_statistics', {'type': 'players_avg_level'}, { 'type': 'players_avg_level', 'data': count_avg_level }, True) def exit(self): self.log.closeFile()
class TweenkApp(): exposed = True cache = memcache_controller.cacheController() cache.cleanCache() controller = controllersLoader() mongo = db.mongoAdapter() caching = True debug = False pages = Set() def __init__(self): self.page_runners = {} pages = [] for item in self.controller.alias: for type_of_method in item['type']: if not type_of_method in self.page_runners: self.page_runners.update({type_of_method: [item]}) else: self.page_runners[type_of_method].append(item) for runner in self.page_runners: if 'default' in self.page_runners[runner][0]['type']: pages += self.page_runners[runner][0]['urls'] else: pages += self.page_runners[runner][0]['type'] for item in pages: self.pages.add(item) def _getCachedContent(self, page): from_cache = False save_cache = False if not self.cache.isPlayer(): loaded = self.cache.cacheLoad(page, cherrypy.request.query_string) if not loaded: save_cache = True else: from_cache = True if from_cache: page_content = loaded['content'] else: page_content = False if self.debug: print '' print page, cherrypy.request.query_string print ' — from cache', from_cache print ' — save cache', save_cache return {'content': page_content, 'need_save': save_cache} def _setCachedContent(self, page, page_content): self.cache.cacheSave(page, cherrypy.request.query_string, page_content) def _load(self, func_name, page, params): for variant in self.page_runners[func_name]: if page in variant['urls']: if self.caching: page_content = self._getCachedContent(page) if not page_content['content']: page_content['content'] = self.controller.controllers[ variant['name']].printPage(page, params) if page_content['need_save']: self._setCachedContent(page, page_content['content']) else: page_content = { 'content': self.controller.controllers[variant['name']].printPage( page, params) } return page_content['content'] return builder.throwWebError(params=params) def _force(self, controller_name, page, params): if self.caching: page_content = self._getCachedContent(page) if not page_content['content']: page_content['content'] = self.controller.controllers[ controller_name].printPage(page, params) if page_content['need_save']: self._setCachedContent(page, page_content['content']) else: page_content = { 'content': self.controller.controllers[controller_name].printPage( page, params) } return page_content['content'] def index(self, **params): return self._load(inspect.stack()[0][3], 'index', params) def default(self, page, **params): if page in self.pages: return self._load(inspect.stack()[0][3], page, params) return self._force('player', page, params) def a(self, page, **params): return self._load(inspect.stack()[0][3], page, params) def u(self, page, **params): return self._load(inspect.stack()[0][3], page, params) def guilds(self, guild_name='', **params): guild_name = guild_name.replace("_", " ") guild_exists = self.mongo.find('guilds', {'name': guild_name}, {'_id': 1}) if guild_exists: return self._force('guild', guild_name, params) else: return self._load(inspect.stack()[0][3], guild_name, params) def events(self, event_id='', **params): try: _id = ObjectId(event_id) event = self.mongo.find('events', {'_id': _id}, {'_id': 1}) except Exception: event = False if event: return self._force('events', event_id, params) else: return self._load(inspect.stack()[0][3], event_id, params) def obj(self, obj_type, guid=0, prefix=0, suffix=0): #page = str(obj_type)+'/'+str(guid)+'/'+str(prefix)+'/'+str(suffix) text = informer.getInfo(obj_type, guid, prefix, suffix) return text obj.exposed = True index.exposed = True default.exposed = True u.exposed = True a.exposed = True guilds.exposed = True events.exposed = True
class WeeklyStats: mongo = db.mongoAdapter() balance = settings.balance() core = settings.core() def __init__(self): pass def updateStats(self): collection = 'weekly_stats' if not self.mongo.collectionExist(collection): self.mongo.createCollection(collection) stats = self.mongo.getu('statistics', {'user_id': 12164662}) prev_weekly = self.mongo.getu(collection) if not prev_weekly: prev_weekly = [] str_prev_weekly = {} for stat in prev_weekly: str_prev_weekly.update({str(stat['user_id']): stat['stats']}) to_update = [] for stat in stats: str_id = str(stat['user_id']) if str_id in str_prev_weekly: diff = { 'monsters': stat['stats']['kills_monster'] - str_prev_weekly[str_id]['monsters'], 'players': stat['stats']['pvp_kills_player'] - str_prev_weekly[str_id]['players'], 'lvl': stat['stats']['lvl'] - str_prev_weekly[str_id]['lvl'] } record = {'user_id': stat['user_id'], 'stats': diff} if diff['monsters'] + diff['players'] + diff['lvl'] > 0: to_update.append(record) normal = { 'monsters': stat['stats']['kills_monster'], 'players': stat['stats']['pvp_kills_player'], 'lvl': stat['stats']['lvl'] } self.mongo.update(collection, {'user_id': stat['user_id']}, {'stats': normal}) else: diff = { 'monsters': stat['stats']['kills_monster'], 'players': stat['stats']['pvp_kills_player'], 'lvl': stat['stats']['lvl'] } record = {'user_id': stat['user_id'], 'stats': diff} if diff['monsters'] + diff['players'] + diff['lvl'] > 1: to_update.append(record) self.mongo.insert(collection, record) for item in to_update: print item
class converter(): mongo = db.mongoAdapter() buff = '' BASE_DIR = os.path.abspath(os.path.split(inspect.getfile( inspect.currentframe() ))[0])+'/../import_base/' def __init__(self): self.RE_SPLIT = re.compile('("(.*?)".*?(,|$))|((.*?),)') def test(self): print('This is test converter string') def splitLine(self, line): result = [] res = re.findall(self.RE_SPLIT, line) if res: for r in res: if r[4] != '': result.append(r[4]) else: result.append(r[1]) return result def loadfile(self,filename): fp = open(self.BASE_DIR+filename,'r') self.buff = fp.readlines() def savefile(self,filename,text): fp = open(filename,'w') fp.write(text) # проверяет корректна ли строка и стоит ли ее обрабатывать def isCorrectString(self,string): return (string[0]>='1') and (string[0][0]<='9') def isCorrectMetricString(self, string): try: int(string[0][1]) except Exception: return False return True # Нормализует строку stroke (ставит значения по умолчанию), # создает хэш буфферных данных из данных из строки и заданных ключей def readToBuff(self,stroke,keys,data_buff): for i in range(0,len(keys)): if stroke[i] == '': stroke[i] = '0' data_buff[keys[i]] = stroke[i] # Сохраняет строковые атрибуты из буфферного хэша # в окончательный def getStrValues(self,data,data_buff,attrs): for attr_name in attrs: data[attr_name] = data_buff[attr_name].rstrip() # Сохраняет целочисленные атрибуты # из буфферного хэша в окончательный def getNumValues(self,data,data_buff,attrs): for attr_name in attrs: if str.find(data_buff[attr_name],'.') > 0: data_buff[attr_name] = round(float(data_buff[attr_name]),1) data[attr_name] = int(data_buff[attr_name]) def getBoolValues(self,data,data_buff,attrs): for attr_name in attrs: data[attr_name] = data_buff[attr_name].rstrip() == '1' # Сохраняет значения бонусов к характеристикам # из буфферного хэша в окончательный def getBonusValues(self,data,data_buff,attrs): data['bonus'] = {} for attr_name in attrs: if data_buff[attr_name] == '': data_buff[attr_name] = '0' if str.find(data_buff[attr_name],'.') > 0: data_buff[attr_name] = round(float(data_buff[attr_name]),1) data['bonus'][attr_name] = int(data_buff[attr_name]) def printInfo(self, name, count): print 'Import '+name+' success' print 'Loaded '+str(count)+' '+name # ---------------------- def settings(self): def settingsClasses(filename): self.loadfile(filename) keys = ['UID','name','priority_stat','available_weapons','starter_equip','damage_type'] items_count = 0 record = {} for line in self.buff: stroke = line.split(',') data_buff = {} data = {} if self.isCorrectString(stroke): self.readToBuff(stroke,keys,data_buff) self.getStrValues(data,data_buff,['name','priority_stat','available_weapons','starter_equip','damage_type']) self.getNumValues(data,data_buff,['UID']) b = {} for key in data: if not key in ['UID']: b.update({key: data[key]}) record.update({str(data['UID']): b}) items_count += 1 self.printInfo('classes', items_count) return record def settingsStats(filename): self.loadfile(filename) keys = ['UID','class', 'str', 'dex', 'int', 'luck', 'DEF', 'DMG', 'HP', 'MP', 'lead', 'karma', 'fame', 'SPD', 'mastery'] items_count = 0 record = {} for line in self.buff: stroke = line.split(',') data_buff = {} data = {} if self.isCorrectString(stroke): self.readToBuff(stroke,keys,data_buff) self.getNumValues(data,data_buff,['UID', 'class', 'str', 'dex', 'int', 'luck', 'DEF', 'DMG', 'HP', 'MP', 'lead', 'karma', 'fame', 'SPD', 'mastery']) stat = {} for key in data: if not key in ['UID', 'class']: stat.update({key: data[key]}) record.update({str(data['class']): stat}) items_count += 1 self.printInfo('classes stats', items_count) return record self.mongo.cleanUp('settings') record = {} record.update({'classes':settingsClasses('settings_classes_names.csv')}) record.update({'classes_stats':settingsStats('settings_classes_stats.csv')}) self.mongo.insert('settings',record) def spells(self): def spellsActions(filename): self.loadfile(filename) keys = ['UID', 'name', 'type', 'power', 'desc', 'monster', 'enemy', 'friend', 'self', 'lvl_min', 'lvl_max', 'effect', 'cost_by_effect', 'restriction_by_lvl', 'img', 'effect_desc', 'effect_value_text'] self.mongo.cleanUp('spells_actions') items_count = 0 actions = {} for line in self.buff: stroke = line.split(',') data_buff = {} data = {} if self.isCorrectString(stroke): self.readToBuff(stroke,keys,data_buff) self.getStrValues(data,data_buff,['name', 'desc', 'effect', 'power', 'img', 'effect_desc', 'effect_value_text']) self.getNumValues(data,data_buff,['UID','type','monster', 'enemy', 'friend', 'self', 'lvl_min', 'lvl_max', 'cost_by_effect', 'restriction_by_lvl']) actions.update({str(data['UID']): data}) self.mongo.insert('spells_actions',data) items_count += 1 self.printInfo('spell actions', items_count) return actions def spells(filename, actions): def getActions(line): list_of_actions = line.split(';') result = [] for item in list_of_actions: number, value = item.split(':') buff = { 'name': actions[number]['name'], 'effect': actions[number]['effect'], 'value': int(value), 'type': actions[number]['type'], 'power': actions[number]['power'] } result.append(buff) return result self.loadfile(filename) keys = ['UID', 'name', 'desc', 'lvl_min', 'lvl_max', 'mana_cost', 'actions', 'keyword', 'img'] self.mongo.cleanUp('spells') items_count = 0 for line in self.buff: stroke = line.split(',') data_buff = {} data = {} if self.isCorrectString(stroke): self.readToBuff(stroke,keys,data_buff) self.getStrValues(data,data_buff,['name', 'desc', 'actions', 'keyword', 'img']) self.getNumValues(data,data_buff,['UID', 'lvl_min', 'lvl_max', 'mana_cost']) data['spell_actions'] = getActions(data['actions']) self.mongo.insert('spells',data) items_count += 1 self.printInfo('spells', items_count) def updateSpellBooks(): static_spells = self.mongo.getu('spells') spellbooks = self.mongo.getu('spellbooks') for spellbook in spellbooks: new_spells = [] for spell in spellbook['spells']: for static_spell in static_spells: if 'spell_UID' in spell: if static_spell['UID'] == spell['spell_UID']: new_spells.append({'spell_id': static_spell['_id'], 'spell_UID': static_spell['UID']}) else: new_spells.append({'spell_id': spell['spell_id']}) self.mongo.update('spellbooks', {'_id': spellbook['_id']}, {'spells': new_spells}) actions = spellsActions('spells_actions.csv') spells('spells.csv', actions) updateSpellBooks() def dungeons(self,filename): self.loadfile(filename) keys = ['UID','name', 'type', 'lvl_min','lvl_max','max_players','desc','holidays', 'power', 'x', 'y', 'hashtag'] self.mongo.cleanUp('dungeons') items_count = 0 for line in self.buff: stroke = line.split(',') data_buff = {} data = {} if self.isCorrectString(stroke): self.readToBuff(stroke,keys,data_buff) self.getStrValues(data,data_buff,['desc','name', 'hashtag']) self.getNumValues(data,data_buff,['UID','type','lvl_min','lvl_max','max_players','holidays', 'power', 'x', 'y']) data.update({'position': {'x': data['x'], 'y': data['y']}}) del data['x'], data['y'] self.mongo.insert('dungeons',data) items_count += 1 self.printInfo('dungeons', items_count) def quests(self,filename): self.loadfile(filename) keys = ['UID','name', 'type', 'lvl_min', 'kill_boss_UID','dungeon_UID','reward_gold','reward_exp', 'hashtag', 'desc'] self.mongo.cleanUp('quests') items_count = 0 for line in self.buff: stroke = line.split(',') data_buff = {} data = {} if self.isCorrectString(stroke): self.readToBuff(stroke,keys,data_buff) self.getStrValues(data,data_buff,['desc','name','hashtag']) self.getNumValues(data,data_buff,['UID','type','kill_boss_UID','dungeon_UID','lvl_min', 'reward_gold', 'reward_exp']) self.mongo.insert('quests',data) items_count += 1 self.printInfo('quests', items_count) def locations(self,filename): self.loadfile(filename) keys = ['UID','name', 'type', 'desc', 'holidays', 'x', 'y', 'hashtag'] self.mongo.cleanUp('locations') items_count = 0 for line in self.buff: stroke = line.split(',') data_buff = {} data = {} if self.isCorrectString(stroke): self.readToBuff(stroke,keys,data_buff) self.getStrValues(data,data_buff,['desc','name', 'hashtag']) self.getNumValues(data,data_buff,['UID','type','holidays', 'x', 'y']) data.update({'position': {'x': data['x'], 'y': data['y']}}) del data['x'], data['y'] self.mongo.insert('locations',data) items_count += 1 self.printInfo('locations', items_count) def pvp_rewards(self,filename): self.loadfile(filename) keys = ['lvl', 'exp'] self.mongo.cleanUp('pvp_rewards') items_count = 0 for line in self.buff: stroke = line.split(',') data_buff = {} data = {} if self.isCorrectString(stroke): self.readToBuff(stroke,keys,data_buff) self.getNumValues(data,data_buff,['lvl', 'exp']) self.mongo.insert('pvp_rewards',data) items_count += 1 self.printInfo('pvp rewards', items_count) def achvs(self, update_existing = False): def achvsNew(filename, collection_name): self.loadfile(filename) keys = ['UID','name','text','type','points','condition','order','visibility', 'img'] self.mongo.cleanUp(collection_name) items_count = 0 for line in self.buff: stroke = line.split(',') data_buff = {} data = {} if self.isCorrectString(stroke): self.readToBuff(stroke,keys,data_buff) self.getStrValues(data,data_buff,['condition','text','name', 'img']) self.getNumValues(data,data_buff,['UID','type','points','order','visibility']) if data['type'] != 0: conditions = data['condition'].split(';') record = {} for condition in conditions: _tmp_ = condition.split(':') try: _tmp_[1] = int(_tmp_[1]) except Exception: pass record.update({_tmp_[0]: _tmp_[1]}) data['condition'] = record self.mongo.insert(collection_name,data) items_count += 1 self.printInfo('achievements', items_count) def updateExistingAchvs(): ac_static = self.mongo.getu('achievements_static', fields={'UID':1}) for achv in ac_static: achv['UID'] = str(achv['UID']) ac_created = self.mongo.getu('achievements') for player in ac_created: record = {} for static in ac_static: found = False for achv_number in player['achvs']: if achv_number == static['UID']: record.update({achv_number: player['achvs'][achv_number]}) found = True if not found: record.update({static['UID']: False}) _id = player['_id'] player['achvs'] = record del player['_id'] self.mongo.update('achievements', {'_id': _id}, player) achvsNew('achvs.csv', 'achievements_static') if update_existing: updateExistingAchvs() def messages(self, filename, collection_name, update_existing = False): def updatingExistingMessages(): def getMessageByUID(records,uid): for record in records: if record['UID'] == uid: return record['message'] messages = self.mongo.getu('messages') created_messages = self.mongo.getu('messages_created') for created_message_array in created_messages: player_updated = 0 for created_message in created_message_array['last']: text = getMessageByUID(messages, created_message['data']['message_UID']) created_message['message'] = text player_updated += 1 if player_updated > 0: self.mongo.update('messages_created', {'user_id': created_message_array['user_id']}, {'last': created_message_array['last']}) self.loadfile(filename) keys = ['UID', 'type', 'message'] self.mongo.cleanUp(collection_name) items_count = 0 for line in self.buff: stroke = line.split(',') data_buff = {} data = {} if self.isCorrectString(stroke): self.readToBuff(stroke,keys,data_buff) self.getStrValues(data,data_buff,['message']) self.getNumValues(data,data_buff,['UID','type']) data.update({'p': 1}) self.mongo.insert(collection_name, data) items_count += 1 self.printInfo('messages', items_count) if update_existing: updatingExistingMessages() def monsters(self,filename, collection_name): self.loadfile(filename) keys = ['UID','name','class','lvl_min','lvl_max','exp','gold', 'area_normal', 'area_dungeon', 'area_coords', 'boss','dungeon', 'text','holidays','art', 'str','dex','int','luck','DEF','DMG','HP','MP','SPD', ] self.mongo.cleanUp(collection_name) items_count = 0 for line in self.buff: stroke = line.split(',') data_buff = {} data = {} if self.isCorrectString(stroke): self.readToBuff(stroke,keys,data_buff) self.getStrValues(data,data_buff,['name','class','text', 'art']) self.getNumValues(data,data_buff,[ 'UID','lvl_min','lvl_max','exp','gold','dungeon','holidays', 'str','dex','int','luck','DEF','DMG','HP','MP','SPD', ]) self.getBoolValues(data, data_buff, ['area_normal', 'area_dungeon', 'area_coords','boss']) stats = {} for stat in ['str','dex','int','luck','DEF','DMG','HP','MP','SPD']: stats.update({stat: data[stat]}) del data[stat] areas_info = {} for area in ['area_normal', 'area_dungeon', 'area_coords']: areas_info.update({area: data[area]}) del data[area] data.update({'stat': stats, 'area': areas_info}) self.mongo.insert(collection_name, data) items_count += 1 self.printInfo('monsters', items_count) def statistics(self, filename, collection_name): self.loadfile(filename) keys = ['UID','name','type','amount','visibility','text', 'order', 'group'] self.mongo.cleanUp(collection_name) items_count = 0 for line in self.buff: stroke = line.split(',') data_buff = {} data = {} if self.isCorrectString(stroke): self.readToBuff(stroke,keys,data_buff) self.getStrValues(data,data_buff,['type','name', 'text']) self.getNumValues(data,data_buff,['UID','amount', 'visibility', 'order', 'group']) self.mongo.insert(collection_name,data) items_count += 1 self.printInfo('statistics', items_count) def updateExistingStats(self): buff_static_stats = self.mongo.getu('statistics_static') static_stats = [] for static in buff_static_stats: static_stats.append(static['name']) players_stats = self.mongo.getu('statistics') for player_stats in players_stats: new_player_stats = {} for stat_name in static_stats: if stat_name in player_stats['stats']: value = player_stats['stats'][stat_name] else: value = 0 new_player_stats.update({stat_name: value}) self.mongo.update('statistics', {'user_id': player_stats['user_id']}, {'stats': new_player_stats}) def shopItems(self, filename, collection_name): self.loadfile(filename) keys = ['item_UID', 'id', 'name', 'type', 'desc', 'author', 'lvl_min', 'cost', 'img'] self.mongo.cleanUp(collection_name) items_count = 0 for line in self.buff: stroke = line.split(',') data_buff = {} data = {} if self.isCorrectString(stroke): self.readToBuff(stroke,keys,data_buff) self.getStrValues(data,data_buff,['name','desc','img', 'author']) self.getNumValues(data,data_buff,['item_UID','type', 'lvl_min','cost']) self.mongo.insert(collection_name,data) items_count += 1 self.printInfo('shop items', items_count) def artworks(self, filename, collection_name): self.loadfile(filename) keys = ['UID', 'name', 'faction', 'race', 'class', 'default', 'desc', 'cost', 'img', 'author', 'link', 'twitter', 'email'] #self.mongo.cleanUp(collection_name) self.mongo.remove(collection_name, {'UID':{'$exists': True}}) authors = {} items_count = 0 for line in self.buff: stroke = line.split(',') data_buff = {} data = {} if self.isCorrectString(stroke): self.readToBuff(stroke,keys,data_buff) self.getStrValues(data,data_buff,['name','desc','img', 'author', 'link', 'twitter', 'email']) self.getNumValues(data,data_buff,['UID', 'faction', 'race', 'class', 'cost', 'default']) if data['twitter'] in authors: author_id = authors[data['twitter']] else: _buff = self.mongo.find('players', {'name': data['twitter']}, {'_id': 1}) if _buff: authors.update({data['name']: _buff['_id']}) author_id = _buff['_id'] else: authors.update({data['name']: ''}) author_id = '' data.update({ 'builtin': True, 'img_info': { 'name': data['author'], 'link': data['link'], 'twitter': data['twitter'], 'email': data['email'], 'verified': True }, 'create_time': time.time(), 'sale_info': { 'active': True }, 'approve': { 'approved': True, 'time': 0, 'approver_id': '' }, 'author': author_id, 'random': random.random() }) del data['link'], data['twitter'], data['email'] self.mongo.insert(collection_name,data) items_count += 1 self.printInfo('artworks', items_count) def clearall(self): for collection_name in [ 'players', 'spellbooks', 'achievements', 'messages_created', 'guild_messages', 'statistics', 'guilds', 'items_created', 'items_crafted', 'spells_crafted_patterns', 'spells_created', 'events', 'game_statistics', 'graph_tweets' ]: self.mongo.cleanUp(collection_name) def actions(self, actions_file, events_file): col_actions = 'actions' col_meta_actions = 'meta_actions' self.loadfile(actions_file) keys = ['UID', 'name', 'desc', 'trigger', 'messages_OK', 'messages_FAIL', 'callback_OK', 'callback_FAIL'] self.mongo.cleanUp(col_actions) self.mongo.cleanUp(col_meta_actions) items_count = 0 actions = {} for line in self.buff: stroke = line.split(',') data_buff = {} data = {} if len(stroke[0]) and stroke[0][0]=='A': self.readToBuff(stroke,keys,data_buff) self.getStrValues(data,data_buff,['UID', 'name', 'desc','trigger']) self.getNumValues(data,data_buff,['messages_OK', 'messages_FAIL','callback_OK', 'callback_FAIL']) uid = data['UID'] self.mongo.insert(col_meta_actions, data) del data['UID'], data['desc'] if data['trigger'] == '0': data['trigger'] = False actions.update({uid: data}) items_count += 1 self.printInfo('actions', items_count) # ========================= self.loadfile(events_file) keys = ['UID', 'mention', 'rt', 'hashtag', 'pvp', 'non_player', 'player_pvp', 'friendly', 'code', 'p', 'trigger'] items_count = 0 is_metric = False _raw_actions = [] events = {} for line in self.buff: stroke = line.split(',') data_buff = {} data = {} if self.isCorrectString(stroke) or is_metric: self.readToBuff(stroke,keys,data_buff) self.getStrValues(data,data_buff,['trigger', 'code']) self.getNumValues(data,data_buff,['UID','mention', 'rt', 'hashtag', 'pvp', 'non_player', 'player_pvp', 'friendly', 'p']) if data['code'] != '0': if not data['UID']: data['UID'] = is_metric else: is_metric = data['UID'] event = { 'tweet_data': { 'mention': bool(data['mention']), 'rt': bool(data['rt']), 'hashtag': bool(data['hashtag']) }, 'player': { 'pvp': bool(data['pvp']) }, 'target': { 'np': bool(data['non_player']), 'enemy': bool(data['player_pvp']), 'friend': bool(data['friendly']) }, 'actions': [] } events.update({ str(data['UID']): event }) _action = { 'code': data['code'], 'p': data['p'], 'trigger': data['trigger'], 'event_id': data['UID'] } _raw_actions.append(_action) items_count += 1 for action in _raw_actions: event_id = str(action['event_id']) del action['event_id'], action['trigger'] action.update(actions[action['code']]) events[event_id]['actions'].append(action) self.mongo.insert(col_actions,events) self.printInfo('events', items_count)
class LBIntegration(): mongo = db.mongoAdapter() log = logger.logger('logs/system_events.log') core = tweenk_core user_name = 'tweeria' _news_hashtag = 'news' RE_SUB = re.compile('#' + _news_hashtag, re.IGNORECASE + re.UNICODE + re.MULTILINE) def __init__(self): pass def getBlogLastPosts(self): def getRelativeDate(input): date = datetime.datetime.fromtimestamp(input) datef = '%d %b' strf = ' %H:%M' return date.strftime(datef + strf) player_info = self.mongo.find('players', {'name': self.user_name}, { '_id': 1, 'token1': 1, 'token2': 1 }) try: auth = tweepy.OAuthHandler(self.core.p_key, self.core.p_secret) auth.set_access_token(player_info['token1'], player_info['token2']) api = tweepy.API(auth) timeline = api.user_timeline(include_entities=1, include_rts=True) except Exception: print "Error..." return False new_posts = [] for post in timeline: is_news = False if 'hashtags' in post.entities: for hashtag in post.entities['hashtags']: if hashtag['text'] == self._news_hashtag: is_news = True break if is_news: text = re.sub(self.RE_SUB, '', post.text) text = text.strip() t = post.created_at # %B date = int(t.strftime("%d")) if date == 1: date_str = 'st' elif date == 2: date_str = 'nd' elif date == 3: date_str = 'rd' else: date_str = 'th' date_str = t.strftime("%d") + date_str + ' ' + t.strftime("%B") text = re.sub( '(http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+)', r'<a href="\1">\1</a>', text) new_posts.append({ 'text': text, 'id': post.id, 'date': date_str }) new_post_update = [] old_posts = self.mongo.find('game_statistics', {'type': 'blog_posts'}) for new_post in new_posts: for old_post in old_posts['posts']: if new_post['id'] == old_post['id']: break else: new_post_update.append(new_post) if new_post_update: for post in new_post_update: old_posts['posts'].append(post) newlist = sorted(old_posts['posts'], key=lambda k: k['id'], reverse=True) self.mongo.update('game_statistics', {'type': 'blog_posts'}, {'posts': newlist}) message = 'Got ' + str( len(new_post_update)) + ' posts from @' + self.user_name self.log.write(message) print message
def readMap(mapname): lines = [] with codecs.open(mapname, "r", "utf-16") as sourceFile: while True: contents = sourceFile.readline() if not contents: break lines.append(contents) mongo = db.mongoAdapter() mongo.cleanUp('map') width = 60 #filelines[0].split(',')[0][2:] height = 50 #filelines[0].split(',')[1] RE_MAP_KEY = re.compile('end-map-key') state = 0 x = 0 y = 0 line_number = 0 features = [] for line in lines: if state == 0: if re.search(RE_MAP_KEY, line): state = 1 elif state == 1: state = 2 elif state == 2: if x == height and y < width: x = 0 y += 1 if y < width: buff = line.split('\t') if buff[0] == 'feature': type_of_object = buff[3].split(':')[1] features.append({ 'y': x - 1, 'x': y, 'type': type_of_object }) else: data = { 'y': x, 'x': y, 'tile': buff[0], 'elevation': int(buff[1].split(':')[1]) } x += 1 mongo.insert('map', data) line_number += 1
class FVFCreator: mongo = db.mongoAdapter() balance = settings.balance() core = settings.core() log = logger.logger('logs/system_events.log') def __init__(self): pass def checkAndCreateFvF(self, FORCE=False): need_to_create_new = True last_fvf = self.mongo.getu('events', search={'type': 'fvf'}, sort={'create_date': -1}, limit=1) if last_fvf: if last_fvf[0][ 'create_date'] + self.balance.FVF_CREATE_TIME > time.time( ): need_to_create_new = False if need_to_create_new or self.core.debug['always_create_fvf'] or FORCE: if last_fvf: not_side = last_fvf[0]['sides'][random.randint(0, 1)] sides = [0, 1, 2] del sides[not_side] side_1, side_2 = sides else: side_1 = random.sample([0, 1, 2], 1)[0] side_2 = Set([0, 1, 2]) side_2.remove(side_1) side_2 = random.sample(side_2, 1)[0] self.createFvF(side_1, side_2) def createFvF(self, side_1, side_2): start_time = time.time() + random.randint( self.balance.FVF_START_TIME_MIN, self.balance.FVF_START_TIME_MAX) desc = '' event = { 'type': 'fvf', 'guild_run': False, 'desc': desc, 'activity': [], 'start_date': start_time, 'create_date': time.time(), 'finish_date': start_time + self.balance.LENGTH_OF_FVF, 'status': 'active', 'promoted_hashtag': [self.balance.FVF_HASHES[side_1], self.balance.FVF_HASHES[side_2]], 'sides': [side_1, side_2], 'sides_names': [self.balance.faction[side_1], self.balance.faction[side_2]], 'people': [] } self.mongo.insert('events', event) message = 'FvF event was created: ' + event['sides_names'][ 0] + ' vs. ' + event['sides_names'][0] self.log.write(message) print message
class postProcess(): mongo = db.mongoAdapter() log = logger.logger('logs/system_events.log') def __init__(self): pass def guildInfoUpdate(self): buff_players = self.mongo.getu('players', fields={'_guild_name':1, '_id':1}) guilds = self.mongo.getu('guilds', fields={'name':1, 'people':1, '_id':1, 'people_count': 1}) players = {} for buff in buff_players: players.update({str(buff['_id']): buff}) for guild in guilds: for player_id in guild['people']: player_str_id = str(player_id) if player_str_id in players: if players[player_str_id]['_guild_name'] != guild['name']: self.mongo.update('players', {'_id': player_id}, {'_guild_name': guild['name']}) else: guild['people_count'] -= 1 self.mongo.update('guilds', {'_id': guild['_id']},{'people': filter (lambda x: x != player_id, guild['people']), 'people_count': guild['people_count']}) def achvUpdate(self): buff_players = self.mongo.getu('players', fields={'achv_points':1, '_id':1, 'user_id':1}) players = {} for buff in buff_players: players.update({ str(buff['user_id']): buff['achv_points'] }) achievements = self.mongo.getu('achievements') for achv in achievements: count = 0 for a in achv['achvs']: if achv['achvs'][a]: count += 1 str_user_id = str(achv['user_id']) if str_user_id in players and players[str_user_id] != count: self.mongo.update('players', {'user_id': achv['user_id']}, {'achv_points': count}) def goldCorrect(self): players = self.mongo.getu('players', {'resources.gold':{'$lt': 0}}, {'_id': 1}) for player in players: self.mongo.update('players', {'_id': player['_id']}, {'resources.gold': int(random.randint(100, 200))}) def process(self): self.guildInfoUpdate() self.achvUpdate() self.goldCorrect() message = 'Post process finished' self.log.write(message) print message