def treat_guess_number(self, number):
guess_number_data = redis.get(get_dark_guess_number_session_name(self.chatbot_user_id))
if guess_number_data is None:
chatbots.get(self.chatbot_user_id).send_text('你要不先对我说：**游戏:猜数字:开启')
return False
data = eval(redis.get(get_dark_guess_number_session_name(self.chatbot_user_id)).decode())
if number == '':
self.display_guess_number(data)
return True
current_number = data['current_number']
tried_record = data['tried_record']
if len(number) != self.digit_count or not number.isdigit():
chatbots.get(self.chatbot_user_id).send_text(
'咱这个数字答案是{0}位数字，我寻思着你在这输的啥JB玩意儿呢！'.format(self.digit_count))
return True
a, b = self.calculate_guess_number(current_number, number)
if a == self.digit_count:
chatbots.get(self.chatbot_user_id).send_text(
'哇你好屌，正确答案就是：「{0}」,秀秀秀！'.format(str(current_number)))
user_login.get_luck_point_by_sender_id(50, self.user_id)
return False
tried_record.append({
"try_number": number,
"a": a,
"b": b
})
data['try_time'] += 1
if data['try_time'] >= self.turn:
chatbots.get(self.chatbot_user_id).send_text(
'游戏结束，正确答案是：「{0}」,小朋友你不行啊！'.format(str(current_number)))
return False
redis.setex(name=get_dark_guess_number_session_name(self.chatbot_user_id), time=3600,
value=str(data))
self.display_guess_number(data)
return True
def get_listener_session_choices(self, user_id: str, chatbot_user_id: str):
choices = redis.get(
self.get_dark_listener_session_name(user_id, chatbot_user_id))
if not choices:
return None
return eval(
redis.get(
self.get_dark_listener_session_name(user_id,
chatbot_user_id)).decode())
def get_maze_image(chatbotUserId):
data = redis.get(get_dark_maze_session_name(chatbotUserId))
if data is None:
return
data = eval(redis.get(get_dark_maze_session_name(chatbotUserId)).decode())
return maze_painter.draw_maze(maze_data=data,
horizon=sight,
row_size=maze_row,
col_size=maze_col)
def start_guess_number(self):
if redis.get(get_dark_guess_number_session_name(self.chatbot_user_id)) is None:
chatbots.get(self.chatbot_user_id).send_text('正在生成数字......')
guess_number_session_data = self.build_guess_number()
redis.setex(name=get_dark_guess_number_session_name(self.chatbot_user_id), time=3600,
value=str(guess_number_session_data))
self.display_guess_number(
data=eval(redis.get(get_dark_guess_number_session_name(self.chatbot_user_id)).decode()))
number = ''
while self.treat_guess_number(number):
number = self.listener.ask(guess_number_operator, '输入任意数字')
shut_down_guess_number(self.chatbot_user_id)
def treat_maze(self, steps):
maze_data = redis.get(get_dark_maze_session_name(self.chatbot_user_id))
if maze_data is None:
chatbots.get(self.chatbot_user_id).send_text('你要不先对我说：**游戏:迷宫:开启')
return False
data = eval(
redis.get(get_dark_maze_session_name(
self.chatbot_user_id)).decode())
preview_location = data['player']['location']
map_location_data = data['map'][preview_location[0]][
preview_location[1]]
for step in steps:
if step == 'a':
if map_location_data[0] == 0 or preview_location[1] == 0:
self.display_maze(data, message='那是一条死路诶...')
return True
preview_location[1] = preview_location[1] - 1
map_location_data = data['map'][preview_location[0]][
preview_location[1]]
elif step == 'w':
if map_location_data[1] == 0 or preview_location[0] == 0:
self.display_maze(data, message='那是一条死路诶...')
return True
preview_location[0] = preview_location[0] - 1
map_location_data = data['map'][preview_location[0]][
preview_location[1]]
elif step == 'd':
if map_location_data[2] == 0 or preview_location[
1] == self.maze_col - 1:
self.display_maze(data, message='那是一条死路诶...')
return True
preview_location[1] = preview_location[1] + 1
map_location_data = data['map'][preview_location[0]][
preview_location[1]]
elif step == 's':
if map_location_data[3] == 0 or preview_location[
0] == self.maze_row - 1:
self.display_maze(data, message='那是一条死路诶...')
return True
preview_location[0] = preview_location[0] + 1
map_location_data = data['map'][preview_location[0]][
preview_location[1]]
elif step == ' ':
continue
if preview_location[1] == self.maze_col - 1 and preview_location[
0] == self.maze_row - 1:
chatbots.get(self.chatbot_user_id).send_text('卧槽牛逼啊！这你都走出来了！')
user_login.rewards(50, self.user_id,
chatbots.get(self.chatbot_user_id), '')
return False
self.display_maze(data, message='接下来是...')
return True
def check_lock(self, sender_id):
if redis.get(
self.get_sign_in_lock_name(sender_id=sender_id)) is not None:
redis.delete(self.get_sign_in_lock_name(sender_id=sender_id))
return True
else:
return False
def route_index():
is_mobile = True if "Mobi" in request.headers.get('User-Agent') else False
current_term = json.loads(redis.get('current_term'))
season = ('Autumn', 'Spring', 'Summer')[int(current_term[1])-1]
return render_template('index.html',
is_mobile=is_mobile,
season=season,
year=current_term[0])
def get_type(slug):
if not slug:
return None
src = redis.get("n:type:" + slug)
if src is None:
return None
data = json.loads(src)
return data
def multiple_choice(self, request_json):
redis_data_str = redis.get(
self.get_dark_quiz_mc_session_name(request_json['chatbotUserId']))
if redis_data_str is None:
data = get_multiple_choice()
redis_data_str = self.put_into_redis(request_json,
data['newslist'][0], 1)
redis_data = eval(redis_data_str)
self.display_mc_quiz(redis_data, request_json)
def true_or_false(self, request_json):
redis_data_str = redis.get(
self.get_dark_quiz_tf_session_name(request_json['chatbotUserId']))
if redis_data_str is None:
data = get_true_or_false()
redis_data_str = self.put_into_redis(request_json,
data['newslist'][0], 0)
redis_data = eval(redis_data_str)
self.display_tf_quiz(redis_data, request_json)
def get_types():
result = {
'type': get_type_type()
}
for slug in redis.smembers('types'):
src = redis.get('n:type:' + slug)
if src is None:
redis.srem('types', slug)
else:
result[slug] = json.loads(src)
return result
def start_dark_maze(self):
if redis.get(get_dark_maze_session_name(self.chatbot_user_id)) is None:
chatbots.get(self.chatbot_user_id).send_text('正在生成迷宫......')
maze_session_data = self.build_maze()
chatbots.get(self.chatbot_user_id).send_text('正在生成人物......')
redis.setex(name=get_dark_maze_session_name(self.chatbot_user_id),
time=3600,
value=str(maze_session_data))
self.listener.current_answer = ' '
while self.treat_maze(self.listener.current_answer):
self.listener.ask(maze_operator, '输入wsad移动')
shut_down_dark_maze(self.chatbot_user_id)
def get_luck_point_by_sender_id(self, sender_id: str):
if sender_id.startswith('/dark_buddy#'):
return {
'user_id': -1,
'value':
int(redis.get(self.get_temp_user_money_name(sender_id)))
}
founded_user = select_by_senderId(sender_id)
number = select_by_statusId_and_userId(2, founded_user["id"]).value
if not number:
number = 0
else:
number = int(number)
return {'user_id': founded_user["id"], 'value': number}
def get(slug):
slug = to_slug(slug)
if ':' in slug:
left, _, right = slug.partition(':')
if left == 'type':
return get_type(right)
if slug == 'type':
return get_type(slug)
src = redis.get("n:" + slug)
if src is None:
return None
node = json.loads(src)
if not 'type' in node:
node['type'] = 'document'
return node
def get_game_session_data(self, request_json):
game_session_data = redis.get(
self.get_dark_spy_session_name(request_json['chatbotUserId']))
if game_session_data is None:
game_session_data = DarkSpyGameSessionData()
game_session_data = json.dumps(game_session_data,
cls=DarkSpyGameSessionDataEncoder,
indent=4)
redis.setex(name=self.get_dark_spy_session_name(
request_json['chatbotUserId']),
time=3600,
value=game_session_data)
# 参考 DarkSpyGameSessionData.decode(eval(json.dumps(game_session_data, cls=DarkSpyGameSessionDataEncoder, indent=4)))
game_session_data = DarkSpyGameSessionData.decode(
eval(game_session_data))
return game_session_data
def treat_dark_quiz(self, answer, type, request_json):
redis_data_str = redis.get(
self.get_session_name_by_type(request_json['chatbotUserId'],
int(type)))
if redis_data_str is None:
return
redis_data = eval(redis_data_str)
if redis_data['answer'] == int(answer):
chatbots.get(request_json['chatbotUserId']).send_action_card(
ActionCard(title="暗黑答题",
text="### 回答正确！6六6！",
btns=[
CardItem(title="再来一题是非题",
url="**游戏:暗黑答题:是非题(10金币)"),
CardItem(title="再来一题单选题",
url="**游戏:暗黑答题:单选题(20金币)")
]))
if type == '0':
user_login.rewards_to_sender_id(10, request_json)
if type == '1':
user_login.rewards_to_sender_id(20, request_json)
else:
chatbots.get(request_json['chatbotUserId']).send_action_card(
ActionCard(title="暗黑答题",
text="### GG！回答错误！正确答案是「{0}」,相关信息：{1}".format(
redis_data['answer_str'],
redis_data['analytic']),
btns=[
CardItem(title="再来一题是非题",
url="**游戏:暗黑答题:是非题(10金币)"),
CardItem(title="再来一题单选题",
url="**游戏:暗黑答题:单选题(20金币)")
]))
user_login.rewards_to_sender_id(-5, request_json)
redis.delete(
self.get_session_name_by_type(request_json['chatbotUserId'],
int(type)))
def route_module_list():
return jsonify(modules=json.loads(redis.get('module_list')))
def get_image_by_uuid(self, uuid):
bytes_image = redis.get(self.get_redis_key(uuid))
if bytes_image is None:
return ''
bytes_image = self.base64_to_image(bytes_image.decode())
return bytes_image
def update_all_events():
module_ids = [m['id'] for m in json.loads(redis.get('module_list'))]
for module_id in module_ids:
update_events_by_id(module_id)
def get_tt_url():
return form_tt_url(*json.loads(redis.get('current_term')))
def delete_old_modules():
list_module_ids = [m['id'] for m in json.loads(redis.get('module_list'))]
redis_keys = redis.keys()
for key in redis_keys:
if key not in list_module_ids and re.match("^m[0-9]+", key):
redis.delete(key)
def get_image(self):
bytes_image = redis.get(self.get_redis_key())
if bytes_image is None:
return ''
image = image_factory.base64_to_image(bytes_image.decode())
return image
from config import redis
def _encode(value):
if type(value) is bytes:
return str(value, 'utf-8')
return value
host = 'game.weixin.qq.com'
accept = '*/*'
accept_lang = 'zh-cn'
referer = 'https://game.weixin.qq.com/cgi-bin/h5/static/profile_v1/index.html?t=g1NlbysGi4KDI5aTA0V-65f9QlaA&ssid=2902&abt=27'
accept_encoding = 'br, gzip, deflate'
ua = _encode(redis.srandmember('wechat_game_uas', 1)[0])
key = _encode(redis.get('wechat_game_key'))
pass_ticket = _encode(redis.get('wechat_game_pass_ticket'))
uin = _encode('MTEyNDEzMjI4MQ%3D%3D')
pgv_pvid = _encode('971741250')
sd_cookie_crttime = _encode('1530872150306')
sd_userid = _encode('34911530872150306')
Res_UserInfo_Dir = '/Users/emrys/Documents/Moba/MobaUserInfo'
Res_Battle_List_Dir = '/Users/emrys/Documents/Moba/MobaBattleList'
Res_Battle_Detail_Dir = '/Users/emrys/Documents/Moba/MobaBattleDetail'
Res_Game_Index_Dir = '/Users/emrys/Documents/Moba/MobaUserIndex'
def get_words(self):
words = redis.get("tianhao:dark_buddy:dark_ji_word_cloud_words")
if words is None:
return ""
return words.decode()
def init_luck_point_4_temp_user(self, count, sender_id):
if redis.get(self.get_temp_user_money_name(sender_id)):
pass
redis.setex(name=self.get_temp_user_money_name(sender_id),
time=3600,
value=count)
if command == 'runserver':
from wsgi import app
app.run(debug = True)
elif command == 'dumpdata':
try:
path = sys.argv[2]
except:
usage()
with open(path, "w") as o:
o.write("[\n ")
first = True
for key in redis.keys("n:*"):
try:
src = redis.get(key)
except:
continue
if not first:
o.write(",\n ")
o.write(src)
first = False
o.write("\n]")
print "Dumped data to %s" % path
elif command == "loaddata":
try:
path = sys.argv[2]
except:
usage()
import requests
import simplejson
from config import redis
_ip_pool = '_ip_pool'
_deprecate_ip_pool = '_deprecate_ip_pool'
_ip_pool_url = 'http://dev.kdlapi.com/api/getproxy/'
orderid = str(redis.get('_ip_pool_orderid'), 'utf-8')
dedup = 1
_key_dedup = 'dedup'
pool_params = {
'orderid': orderid,
'num': 1000,
'b_pcchrome': 1,
'b_pcie': 1,
'b_pcff': 1,
'b_android': 1,
'b_iphone': 1,
'protocol': 1,
'method': 2,
'an_an': 1,
'an_ha': 1,
'sp1': 1,
'sp2': 1,
'quality': 1,
'sort': 1,
'format': 'json',
'sep': 1,
}
