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
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 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
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 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
