def evolution(self, raw_list, user_id, pay_time):
"""
进化（吞噬）
:param raw_list: 原材料，只能为同等级的材料
:return:
"""
if (not raw_list) or len(raw_list) == 0:
logger.exception('原材料为空！')
raise RuntimeError('原材料列表为空')
raw_material_level = raw_list[0].level
if raw_material_level + 1 not in self.cards.keys():
logger.info('已经是最高级的卡牌，不能合成')
return None
logger.info('删除原材料')
# 删除原材料
for raw_material in raw_list:
mysql_util.query("""
UPDATE `draw_record` SET is_valid=0 WHERE id=%s
""", (raw_material.id,))
# 从高1级的卡中获得一张
new_card = util.choice(self.cards[raw_material_level + 1])
logger.debug('合成的新卡: %s' % new_card)
mysql_util.query("""
INSERT INTO `draw_record` (`supporter_id`, `card_id`, `draw_time`, `is_valid`) VALUES
(%s, %s, %s, %s)
""", (user_id, new_card.id, pay_time, 1))
logger.info('合卡完成')
def pk_list_sort(self, modian_entity_list, title):
"""
PK活动，对金额进行排序
:param modian_entity_list:
:param title:
:return:
"""
def cmp_2(x, y):
if x.current >= y.current:
return 1
else:
return -1
import functools
modian_entity_list.sort(key=functools.cmp_to_key(cmp_2), reverse=True)
msg = '{}:\n'.format(title)
for i in range(len(modian_entity_list)):
wds = modian_entity_list[i]
if i == 0:
sub_msg = '%d. %s\t支持人数: %s\t当前进度: %.2f元\n' % (
i + 1, wds.title, wds.support_num, wds.current)
my_logger.debug('【总选PK】{}'.format(sub_msg))
else:
diff = modian_entity_list[i].current - modian_entity_list[
i - 1].current
sub_msg = '%d. %s\t支持人数: %s\t当前进度: %.2f元\t -%.2f元\n' % (
i + 1, wds.title, wds.support_num, wds.current, diff)
msg += sub_msg
return msg
def read_config(self):
config_path = os.path.join(BASE_DIR, 'data/card_draw/cards3.txt')
weight_path = os.path.join(BASE_DIR, 'data/card_draw/weight.txt')
card_datas = util.read_txt(config_path)
weight_datas = util.read_txt(weight_path)[0]
self.weights = [] # SR,SSR,UR卡的概率
self.cards = {} # 所有卡，按等级分，不包含已过期卡牌
self.all_cards = {} # 所有卡，按等级分，包含已下架卡牌
self.cards_single = {} # 根据ID查询卡
for line in card_datas:
strs = line.split(',')
card = Card(int(strs[0]), strs[3], CardType(int(strs[2])), CardLevel(int(strs[1])), int(strs[4]), strs[5])
if card.level not in self.cards:
self.cards[card.level] = []
if card.level not in self.all_cards:
self.all_cards[card.level] = []
self.all_cards[card.level].append(card)
self.cards_single[card.id] = card
if int(strs[6]) == 0: # 如果卡片无效，则跳过
continue
self.cards[card.level].append(card)
logger.debug(self.cards)
strs = weight_datas.split(',')
for weight in strs:
self.weights.append(float(weight))
def init_order_queues(self):
for modian_entity in self.modian_project_array:
try:
my_logger.info('初始化%s的订单队列', modian_entity.pro_id)
my_logger.debug(self.order_queues)
if modian_entity.pro_id not in self.order_queues:
self.order_queues[modian_entity.pro_id] = set()
my_logger.debug('队列为空，重新初始化队列')
else:
my_logger.debug('队列不为空，不重新初始化队列')
continue
my_logger.debug('项目%s队列长度: %s', modian_entity.pro_id, len(self.order_queues[modian_entity.pro_id]))
# 先拉一把项目的基本资料
self.get_project_profiles(modian_entity)
orders = self.query_project_orders(modian_entity)
for order in orders:
backer_money_icon = order.find(class_='icon-payment')
if not backer_money_icon: # 纯评论，直接跳过
continue
comment_id = order.get('data-reply-id')
# oid使用项目id和评论id拼装
oid = str(modian_entity.pro_id) + str(comment_id)
my_logger.debug('oid: %s', oid)
self.order_queues[modian_entity.pro_id].add(oid)
except Exception as e:
my_logger.error('初始化订单队列失败！')
my_logger.exception(e)
def donate(modian_id, pay_amount):
MIN_AMOUNT = 10
rst = ''
has_created, character = created(modian_id)
if has_created:
my_logger.info('已经创建了人物: %s' % modian_id)
# 如果已经创建
my_logger.debug('%s触发了随机事件（施工中）' % character.name)
if pay_amount < MIN_AMOUNT:
return ''
tmp = pay_amount
amounts = [200, 100, 50, 20, 10]
# amounts = [i / 10 for i in amounts]
max_event = 3 # 最多触发3次事件
idx = 0
while max_event > 0 and idx < len(amounts):
event_time = int(tmp / amounts[idx])
event_time = max_event if event_time > max_event else event_time
for i in range(event_time):
sub_event_str = handle_event(amounts[idx], character)
rst += sub_event_str
my_logger.debug(sub_event_str)
# rst += '----------------------------\n'
max_event -= event_time
tmp = tmp % amounts[idx]
idx += 1
rst += '【{}】当前属性：\n攻：{}, 防: {}, 气: {}, 运：{}, 魅力: {}\n'.format(
character.name, character.prop1, character.prop2, character.prop3,
character.prop4, character.prop5)
else:
my_logger.info('未创建人物, modian_id: %s' % modian_id)
if pay_amount >= MIN_AMOUNT:
rst = create_character(modian_id)
return rst
def login(self, account, passwd):
"""
登录，获取SIGNATURE
:param account:
:param passwd:
:return:
"""
url = 'https://www.tao-ba.club/signin/phone'
data = {
'account': account,
'pushid': '',
'loginpw': passwd,
'device': {
'platform': 'other',
'screen': '1680*1050',
'imei': 'XXX',
'uuid': 'YYY',
'version': 'v1.0.0',
'vendor': 'ZZZ'
},
'requestTime': int(time.time() * 1000),
'pf': 'h5'
}
header = {
'Content-Type':
'application/json',
'User-Agent':
'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.122 Safari/537.36',
}
r = self.session.post(url, data=self.encrypt(data), headers=header)
r = self.decrypt(r.text)
if r['code'] == 0:
my_logger.debug('登录成功')
self.token = r['token']
def can_draw(self):
"""
是否可以抽中卡, 概率1/3
:return:
"""
candidates = [i for i in range(3)]
rst = util.choice(candidates)
logger.debug('是否抽中卡: %s' % (rst[0] < 1))
return rst[0] < 1
def make_post_params(self, post_fields):
"""
获取post请求需要的参数
:param post_fields:
:return:
"""
sign = self.__make_signature(post_fields)
post_fields['sign'] = sign
my_logger.debug('post_fields: %s', post_fields)
return post_fields
def monitor_modian():
"""
监控摩点
:return:
"""
global modian_handler
my_logger.debug('监控摩点集资情况')
for modian in global_config.MODIAN_ARRAY:
time0 = time.time()
r = modian_handler.query_project_orders(modian)
modian_handler.parse_order_details(r, modian)
my_logger.debug('查询摩点集资情况所消耗的时间为: %s秒', time.time() - time0)
def save_character(character):
"""
将更新后的任务保存到数据库
:param character:
:return:
"""
my_logger.debug('将更新后的任务保存到数据库')
mysql_util.query(
"""
UPDATE `t_character` SET `name`=%s, `prop1`=%s, `prop2`=%s, `prop3`=%s, `prop4`=%s, `prop5`=%s
WHERE `modian_id`=%s
""", (character.name, character.prop1, character.prop2, character.prop3,
character.prop4, character.prop5, character.id))
def save_event(modian_id, event_id, event_remark):
"""
保存事件到数据库
:param modian_id
:param event_id
:param event_remark
:return:
"""
my_logger.debug('保存事件到数据库')
mysql_util.query(
"""
INSERT INTO `t_event` (`modian_id`, `event_id`, `event_remark`) VALUES
(%s, %s, %s)
""", (modian_id, event_id, event_remark))
def init_order_queues(self):
for modian_entity in self.modian_project_array:
try:
my_logger.info('初始化%s的订单队列', modian_entity.pro_id)
my_logger.debug(self.order_queues)
if modian_entity.pro_id not in self.order_queues:
self.order_queues[modian_entity.pro_id] = set()
my_logger.debug('队列为空，重新初始化队列')
else:
my_logger.debug('队列不为空，不重新初始化队列')
continue
# self.order_queues[modian_entity.pro_id] = set()
my_logger.debug('项目%s队列长度: %s', modian_entity.pro_id,
len(self.order_queues[modian_entity.pro_id]))
orders = self.query_project_orders(modian_entity)
# retry_time = 0
# while retry_time < 5:
# retry_time += 1
# if len(orders) == 0:
# my_logger.debug('请求订单失败，第%s次重试', retry_time)
# orders = self.query_project_orders(modian_entity)
# else:
# break
for order in orders:
user_id = order['user_id']
pay_time = order['pay_time']
oid = uuid.uuid3(uuid.NAMESPACE_OID,
str(user_id) + pay_time)
self.order_queues[modian_entity.pro_id].add(oid)
except Exception as e:
my_logger.error('初始化订单队列失败！')
my_logger.exception(e)
def init_order_queues(self):
for group_account_entity in self.group_account_project_array:
try:
my_logger.info('初始化%s的订单队列',
group_account_entity.group_account_id)
my_logger.debug(self.order_queues)
if group_account_entity.group_account_id not in self.order_queues:
self.order_queues[
group_account_entity.group_account_id] = set()
my_logger.debug('队列为空，重新初始化队列')
else:
my_logger.debug('队列不为空，不重新初始化队列')
continue
my_logger.debug(
'项目%s队列长度: %s', group_account_entity.group_account_id,
len(self.order_queues[
group_account_entity.group_account_id]))
orders = self.query_project_orders(group_account_entity)
for order in orders:
listid = int(order['listid'])
self.order_queues[
group_account_entity.group_account_id].add(listid)
except Exception as e:
my_logger.error('初始化订单队列失败！')
my_logger.exception(e)
def save_character(character):
"""
将更新后的任务保存到数据库
:param character:
:return:
"""
my_logger.debug('将更新后的任务保存到数据库')
mysql_util.query(
"""
UPDATE `t_character` SET `name`=%s, `prop1`=%s, `prop2`=%s, `prop3`=%s, `prop4`=%s, `prop5`=%s,
`num_of_fragment`=%s, `loc_x`=%s, `loc_y`=%s
WHERE `modian_id`=%s
""", (character.name, character.prop1, character.prop2, character.prop3,
character.prop4, character.prop5, character.num_of_fragment,
character.current_point.x, character.current_point.y, character.id))
def get_all_orders(self, modian_entity):
"""
获取全部订单
:return:
"""
orders = []
page = 1
while True:
my_logger.debug('获取全部订单，第{}页'.format(page))
sub_orders = self.query_project_orders(modian_entity, page)
if len(sub_orders) > 0:
orders.extend(sub_orders)
page += 1
else:
break
return orders
def get_current_score(self, modian_id):
"""
获取当前积分
:param modian_id:
:return:
"""
logger.debug('获取当前积分: {}'.format(modian_id))
score = 0
rst = mysql_util.select_one("""
SELECT CONCAT(SUM(`score`)) FROM `t_card_score` WHERE `modian_id`=%s
""", (modian_id,))
if rst and len(rst) > 0:
if rst[0] is not None:
logger.debug('current score: {}'.format(rst[0]))
score = str(rst[0], encoding='utf-8')
print(score)
return score
def get_current_points(pro_id):
if pro_id not in [SWEET_PRO_ID, TREAT_PRO_ID]:
return 0
time0 = time.time()
points = 0
rst = mysql_util.select_all(
"""
SELECT `point` from `point_detail` WHERE `pro_id` = %s
""", (pro_id, ))
if not rst:
return points
for a in rst:
points += a[0]
my_logger.info('当前累计分数: %s' % points)
my_logger.debug('该函数共消耗时间: %s' % (time.time() - time0))
return points
def created(modian_id):
"""
是否创建人物，以摩点id判断
:param modian_id: 摩点id
:return:
"""
my_logger.info('查询人物是否创建，modian_id: %s' % modian_id)
rst = mysql_util.select_one(
"""
SELECT * FROM `t_character` WHERE modian_id=%s
""", (modian_id, ))
my_logger.debug(type(rst))
my_logger.debug(rst)
# my_logger.debug('rst: %s' % rst)
if rst and len(rst) > 0:
return True, Character(modian_id, str(rst[1], encoding='utf-8'),
rst[2], rst[3], rst[4], rst[5], rst[6])
else:
return False, None
def get_today_jizi_ranking_list(self, pro_id):
"""
获取当日集资排名
:param pro_id:
:return: 排名tuple 格式（supporter_id, supporter_name, total_amount, rank)
"""
# 总额
rst2 = mysql_util.select_one(
"""
select SUM(`order`.backer_money) as total
from `order`
where `order`.pro_id = %s
and CURDATE()=DATE(`order`.pay_time);
""", (pro_id, ))
total = rst2[0]
# 集资排名
rst = mysql_util.select_all(
"""
select `supporter`.id, `supporter`.name, SUM(`order`.backer_money) as total
from `order`, `supporter`
where `supporter`.id=`order`.supporter_id
and `order`.pro_id = %s
and CURDATE()=DATE(`order`.pay_time)
group by `order`.supporter_id
order by total desc;
""", (pro_id, ))
cur_rank = 0
row_tmp = 0
last_val = -1
new_rst = []
for rank in rst:
row_tmp += 1
if rank[2] != last_val:
cur_rank = row_tmp
last_val = rank[2]
rank_tmp = rank + (cur_rank, )
new_rst.append(rank_tmp)
my_logger.debug(new_rst)
return new_rst, total
def get_current_and_target(self, modian_entity):
"""
获取当前进度和总额（摩点API版本）
:param modian_entity:
:return:
"""
my_logger.info('获取当前进度和总额: pro_id: %s', modian_entity.pro_id)
api = 'https://wds.modian.com/api/project/detail'
params = {'pro_id': modian_entity.pro_id}
r = requests.post(api,
self.make_post_params(params),
headers=self.modian_header()).json()
my_logger.debug(r)
if int(r['status']) == 0:
data_json = r['data'][0]
pro_name = data_json['pro_name']
target = data_json['goal']
current = data_json['already_raised']
backer_count = data_json['backer_count']
my_logger.info('目标: %s, 当前进度: %s', target, current)
return target, current, pro_name, backer_count
else:
raise RuntimeError('获取项目筹款结果查询失败')
def create_character(modian_id):
"""
创建人物
:return:
"""
my_logger.info('创建人物, modian_id: %s' % modian_id)
# 随机姓名
random_name = TOTAL_NAMES.pop()
my_logger.debug('随机姓名: %s' % random_name)
# 随机生成属性
prop1 = random.randint(40, 70)
prop2 = random.randint(30, 60)
prop3 = random.randint(5, 20)
prop4 = random.randint(0, 50)
prop5 = random.randint(30, 50)
mysql_util.query(
"""
INSERT INTO `t_character` (`modian_id`, `name`, `prop1`, `prop2`, `prop3`, `prop4`, `prop5`)
VALUES (%s, %s, %s, %s, %s, %s, %s)
""", (modian_id, random_name, prop1, prop2, prop3, prop4, prop5))
intro_words = [
"郁雷之声渐响，轰轰不绝。河海尚远，而耳中尽是浪涛之声。 似有一名字伴雷声入耳，仔细辨来，名为：【{}】。".format(
random_name),
"湖山深处,但见竹木阴森,苍翠重叠,不雨而润,不烟而晕, 晨雾朦胧处现一少年，“在下【{}】，请问此处可是星梦谷？”".format(
random_name),
"月照竹林风飞叶，竹影之下见刀光。小侠籍籍无名，仅有此片竹林识得其名为【{}】".format(random_name),
"嗖的一声，一支羽箭从山坳后射了出来，呜呜声响，划过长空，【{}】松开弓弦，雁落平沙。".format(random_name),
"灯宵月夕，雪际花时，市集喧闹却也听得句柔声细语：“这文书写有【{}】之名，可是你掉的？”".format(random_name)
]
# 随机挑选一个出场方式
intro = util.choice(intro_words)
report_str = '%s\n' % intro[0]
report_str += '%s的武侠世界开启, 属性：\n攻: %s, 防: %s, 气: %s, 运: %s, 魅力: %s\n' % (
random_name, prop1, prop2, prop3, prop4, prop5)
return report_str
def sync_names():
"""
程序启动时，本地和db同步下已使用的姓名
:return:
"""
global TOTAL_NAMES
# 从DB获取已使用的姓名
rst = mysql_util.select_all("""
SELECT `name` from `t_character`;
""")
my_logger.debug(type(rst))
my_logger.debug(rst)
# my_logger.debug('names in db: %s' % rst)
name_used = []
if rst:
for a in rst:
name_used.append(str(a[0], encoding='utf-8'))
my_logger.debug('name_used: %s' % name_used)
# name_used = ['刘超', '李凡']
# return list1 - list2
total_copy = TOTAL_NAMES.copy()
TOTAL_NAMES = total_copy.difference(set(name_used))
def query_project_orders(self, taoba_entity, page=1, limit=10):
"""
批量获取订单
:param taoba_entity:
:param page:
:param limit:
:return:
"""
all_orders = []
my_logger.info('查询项目订单, id: %s', taoba_entity.taoba_id)
url = 'https://www.tao-ba.club/idols/refund/orders'
page = 0
while True:
data = {
'id': taoba_entity.taoba_id,
'offset': page * 25,
'ismore': False,
'requestTime': int(time.time() * 1000),
'pf': 'h5'
}
my_logger.info('taoba token: {}'.format(self.token))
my_logger.debug('data: {}'.format(data))
my_logger.debug('data: {}'.format(self.encrypt(data)))
my_logger.debug('header: {}'.format(self.taoba_header()))
r = self.session.post(url=url,
data=self.encrypt(data),
headers=self.taoba_header())
r = self.decrypt(r.text)
if int(r['code']) != 0:
raise RuntimeError('获取订单信息失败')
orders = r['list']
my_logger.info('项目订单: page: %s, orders: %s, len: %s', page + 1,
orders, len(orders))
if not orders:
break
all_orders.extend(orders)
page += 1
return all_orders
def handle_event(pay_amount, character):
if game_is_over(character.id):
return '游戏结束'
result = ''
event_list_j = event_json[str(int(pay_amount))]
event_list = []
weight_list = []
for event_j in event_list_j:
event = Event(event_j['id'], event_j['name'], pay_amount,
event_j['weight'])
event_list.append(event)
weight_list.append(event_j['weight'])
# 按概率选出是哪个大类的事件
idx = util.weight_choice(event_list, weight_list)
choice = event_list[idx]
my_logger.debug('触发事件前属性: %s' % character)
my_logger.info('触发事件: %s' % choice.name)
event_id = choice.id
event_remark = ''
if choice.id == 401: # 个体-遇见NPC
monsters = ['本院教师', '别院教师', '皮皮鬼', '托尼老师', '款款']
weights = [30, 30, 30, 8, 2]
hit_idx = util.weight_choice(monsters, weights)
hit = monsters[hit_idx]
event_remark = hit
if hit == '款款':
# 赠送梦的碎片
result += '【{}】在身边发现款款！\n款款赠与了一块梦的碎片，并说了声再见。\n【{}】运气+10，魅力+5\n'.format(
character.name, character.name, character.name)
character.use_good(Good('款款', 0, 0, 0, 10, 5))
character.num_of_fragment += 1
event_id = 4011
else:
result += '{}突然出现在【{}】附近\n'.format(character.name, hit)
rand_int = random.randint(1, 100)
if rand_int <= 75:
# 75%几率获胜
result += '运气看来不错，{}并没有看到你。\n【{}】运气+5，专注+3\n'.format(
hit, character.name, hit, character.name)
character.use_good(Good('没有被NPC发现', 0, 3, 0, 5, 0))
event_id = 4012
else:
result += '{}发现你啦，{}被遣送回学院\n运气-2，专注-5，返回出生点\n'.format(
hit, character.name, character.name)
character.use_good(Good('战斗胜利', 0, -5, 0, -2, 0))
# 返回出生点
character.return_to_origin()
event_id = 4013
result += character.random_move()
save_character(character)
elif choice.id == 402: # 个体-物品
idx = random.randint(0, 1)
if idx == 0: # 拾取
rand_int = random.randint(1, 100)
if rand_int <= 90:
# 普通事件
locations = ['门后', '台阶', '转角处', '草丛中', '路边']
item = util.choice(item_list)[0]
result += '【{}】在 {} 拾到 {}，\n{}\n'.format(
character.name,
util.choice(locations)[0], item.name,
item.property_change())
character.use_good(item)
event_id = 4021
event_remark = item.name
else:
# 物品2类
equipment = util.choice(equipment_list)[0]
result += '{}在无意中发现了什么。去看看。这是什么？\n {}获得了{}精神+15，运气+15，魅力+10'.format(
character.name, character.name, equipment.name)
# result += '【{}】在草丛中发现一把绝世好刀，动了动食指，点击一下，获得屠龙宝刀。\n【{}】攻击+15，运+15，魅力+10\n'.format(character.name,
# character.name)
character.prop1 += 15
character.prop4 += 15
character.prop5 += 10
event_id = 4022
event_remark = equipment.name
else: # 交易
locations = ['商店']
location = util.choice(locations)[0]
equipment = util.choice(equipment_list)[0]
rand_int = random.randint(1, 100)
if rand_int <= 100:
# 普通事件
result += '【{}】在 {} 处购得{}，{}\n'.format(
character.name, location, equipment.name,
equipment.property_change())
character.use_good(equipment)
event_id = 4023
event_remark = equipment.name
# else:
# # 假货
# result += '【{}】在 {} 处购得{}，不料过了半日才发现竟是被奸商所骗，{}竟是赝品，运-8\n'.format(character.name, location, equipment.name,
# equipment.name)
# character.use_good(Good('奸商', 0, 0, 0, -8, 0))
# event_id = 4024
# event_remark = equipment.name
result += character.random_move()
save_character(character)
elif choice.id == 403: # 互动-相识
all_character = get_all_character()
rand_character = util.choice(all_character)[0]
# locations = ['酒肆', '茶馆', '驿站']
# location = util.choice(locations)[0]
result += '【{}】在这看到了一个身影，原来也是偷跑出来的【{}】，认识一下吧。\n'.format(
character.name, rand_character.name)
result += character.random_move()
save_character(character)
event_remark = rand_character.name
elif choice.id == 404: # 互动-交恶
all_character = get_all_character()
rand_character = util.choice(all_character)[0]
result += '【{}】发现，原来这里还有【{}】，不能让他就这么溜过去，让他暴露吧。\n'.format(
character.name, rand_character.name)
result += character.random_move()
save_character(character)
event_remark = rand_character.name
elif choice.id == 405: # 互动-PK
all_character = get_all_character()
rand_character = util.choice(all_character)[0]
word_list = [
'【{}】只顾低头行走，被【{}】一头撞上，两人发生争执，要分个高下才肯罢休。\n'.format(
character.name, rand_character.name),
'【{}】和【{}】在城堡里狭路相逢，既然躲不过，那么来较量一下吧。\n'.format(
character.name, rand_character.name)
]
event_remark = rand_character.name
result += util.choice(word_list)[0]
pk_rst = character.pk(rand_character)
if pk_rst:
result += '【{}】魔法略胜一筹，多年的勤学苦练终于派上用场。\n【{}】精神+6，专注+5，智慧+5，运气+3，魅力+8；\n【{}】精神-6，专注-5，智慧-5，运气-3，魅力-8\n'.format(
character.name, character.name, rand_character.name)
character.use_good(Good('PK胜利', 6, 5, 5, 3, 8))
rand_character.use_good(Good('PK失败', -6, -5, -5, -3, -8))
event_id = 4051
else:
result += '【{}】在较量中棋差一招，只怪自己学艺不精，道歉认输便得作罢。\n【{}】精神-6，专注-5，智慧-5，运气-3，魅力-8；\n【{}】精神+6，专注+5，智慧+5，运气+3，魅力+8\n'.format(
character.name, character.name, rand_character.name)
character.use_good(Good('PK失败', -6, -5, -5, -3, -8))
rand_character.use_good(Good('PK胜利', 6, 5, 5, 3, 8))
event_id = 4052
result += character.random_move()
save_character(character)
save_character(rand_character)
elif choice.id == 406: # 互动-学院势力
# TODO
result += '学院压制'
event_remark = '学院压制'
result += character.random_move()
elif choice.id == 301: # 学艺-基础
skill = util.choice(skill1_list)[0]
character.use_good(skill)
result += '【{}】刻苦修炼，终于习得【{}】，\n{}\n'.format(character.name, skill.name,
skill.property_change())
event_remark = skill.name
result += character.random_move()
save_character(character)
elif choice.id == 302: # 学艺-进阶
skill = util.choice(skill2_list)[0]
character.use_good(skill)
result += '【{}】刻苦修炼，终于习得【{}】，\n{}\n'.format(character.name, skill.name,
skill.property_change())
event_remark = skill.name
result += character.random_move()
save_character(character)
elif choice.id == 201: # 门派
mentor = util.choice(SCHOOLS)[0]
result += '【{}】骨骼精奇天资聪慧，{}对他青睐有加，亲自传授本门武功。\n【{}】获得真传，攻+35，防+30，气+30，运+20，魅力+40\n'.format(
character.name, mentor, character.name)
character.prop1 += 35
character.prop2 += 30
character.prop3 += 30
character.prop4 += 20
character.prop5 += 40
event_remark = mentor
result += character.random_move()
save_character(character)
elif choice.id == 101: # 其他-得子
name = ['子', '女', '哪吒']
choice_name = util.choice(name)[0]
result += '行走江湖，总有意外，【{}】十月怀胎，诞下一{}。\n'.format(character.name,
choice_name)
event_remark = choice_name
result += character.random_move()
save_character(character)
elif choice.id == 102: # 其他-称号升级
result += '【{}】武功日益精进，救死扶伤匡扶正义，昔日的【无名小侠】如今已【名震江湖】，魅力+88\n'.format(
character.name, )
character.prop5 += 88
result += character.random_move()
save_character(character)
event_remark = '称号升级'
my_logger.debug('触发事件后属性: %s' % character)
save_event(character.id, event_id, event_remark)
return result
def get_current_points(pro_id):
if pro_id not in [FXF_PRO_ID, WJL_PRO_ID]:
return 0
time0 = time.time()
# 当前集资人数
fxf_supporter_num = get_current_supporter_num(FXF_PRO_ID)
wjl_supporter_num = get_current_supporter_num(WJL_PRO_ID)
supporter_num_points = 0
rst = mysql_util.select_all(
"""
select * from `order` where pro_id=%s and `backer_money` <> 99.9
""", (pro_id, ))
points = 0
for order in rst:
"""
(order_id, supporter_id, backer_money, pay_time, pro_id)
"""
add = plus_points(pro_id, order[2])
points += add
if pro_id == FXF_PRO_ID:
make_trouble_time_other = get_make_trouble_time(WJL_PRO_ID)
make_trouble_time_self = get_make_trouble_time(FXF_PRO_ID)
bonus_minus_time = get_plus_10_times(WJL_PRO_ID)
# 对方通过捣乱给己方扣除的分数
make_trouble_points = make_trouble_time_other * WJL_MAKE_TROUBLE_POINTS
# 通过累计+10分的记录为对方扣除的分数（每5次扣除10分）
bonus_minus_points = int(bonus_minus_time // 5) * 10
my_logger.debug('汪佳翎共给冯晓菲捣乱%s次，共扣除%s分' %
(make_trouble_time_other, make_trouble_points))
my_logger.debug('冯晓菲共有%s次+10分的记录，为汪佳翎扣除%s分' %
(bonus_minus_time, bonus_minus_points))
if fxf_supporter_num > wjl_supporter_num:
supporter_num_points = 61
elif pro_id == WJL_PRO_ID:
make_trouble_time_self = get_make_trouble_time(WJL_PRO_ID)
make_trouble_time_other = get_make_trouble_time(FXF_PRO_ID)
bonus_minus_time = get_plus_10_times(FXF_PRO_ID)
# 对方通过捣乱给己方扣除的分数
make_trouble_points = make_trouble_time_other * FXF_MAKE_TROUBLE_POINTS
# 通过累计+10分的记录为对方扣除的分数（每5次扣除10分）
bonus_minus_points = int(bonus_minus_time // 5) * 10
my_logger.debug('冯晓菲共给汪佳翎捣乱%s次，共扣除%s分' %
(make_trouble_time_other, make_trouble_points))
my_logger.debug('冯晓菲共有%s次+10分的记录，为汪佳翎扣除%s分' %
(bonus_minus_time, bonus_minus_points))
if fxf_supporter_num < wjl_supporter_num:
supporter_num_points = 61
else:
return 0
my_logger.info('%s人头数得分为:%s' % (pro_id, supporter_num_points))
# 己方捣乱加成分数
my_logger.info('%s捣乱次数为: %s' % (pro_id, make_trouble_time_self))
make_trouble_bonus_points = 10 * int(make_trouble_time_self // 5)
my_logger.info('%s捣乱共加分: %s' % (pro_id, make_trouble_bonus_points))
# 分数计算方法: 基本得分 - 对方捣乱分数 + 己方捣乱分数(每5次捣乱+10分） - 额外分数（每有5次+10分项目 为对方-10分）+ 人头得分
# points = points - make_trouble_points + make_trouble_bonus_points - bonus_minus_points + supporter_num_points
points = points - make_trouble_points + make_trouble_bonus_points - bonus_minus_points
my_logger.info('当前%s的总得分为: %s' % (pro_id, points))
my_logger.debug('该函数共消耗时间: %s' % (time.time() - time0))
return points
def update_modian_conf():
global modian_handler
time0 = time.time()
my_logger.info('读取摩点配置')
ConfigReader.read_conf()
# modian_json = json.load(open("data/modian.json", encoding='utf8'))
# modian_json = json.load(open("data/weixin_group_account.json", encoding='utf8'))
modian_json = json.load(open("data/taoba_account.json", encoding='utf8'))
modian_handler.login(modian_json['taoba_account'],
modian_json['taoba_passwd'])
global_config.MODIAN_POSTSCRIPTS = modian_json['modian_postscripts']
# 摩点集资PK链接数组初始化
global_config.MODIAN_NEED_DISPLAY_PK = modian_json[
'modian_need_display_pk']
for modian_pk_j in modian_json['modian_pk_activities']:
global_config.MODIAN_PK_ARRAY.append(modian_pk_j)
# 是否需要开启抽卡功能
global_config.MODIAN_CARD_DRAW = modian_json['modian_need_card_draw']
# global_config.MODIAN_300_ACTIVITY = modian_json['modian_300_activity']
# 需要适应同时开多个链接的情况
global_config.MODIAN_ARRAY = []
for modian_j in modian_json['monitor_activities']:
# if modian_j['modian_need_display_rank'] is False:
# modian = ModianEntity(modian_j['modian_link'], modian_j['modian_title'], modian_j['modian_pro_id'], False,
# modian_j['broadcast_groups'])
# modian = GroupAccountEntity(modian_j['modian_link'], modian_j['modian_title'], modian_j['modian_pro_id'],
# modian_j['broadcast_groups'], modian_j['qrcode'])
modian = TaoBaEntity(modian_j['modian_link'], modian_j['modian_title'],
modian_j['modian_pro_id'],
modian_j['broadcast_groups'], modian_j['qrcode'])
# elif modian_j['wds_need_display_rank'] is True:
# modian = ModianEntity(modian_j['modian_link'], modian_j['modian_title'], modian_j['modian_pro_id'], True,
# modian_j['broadcast_groups'])
global_config.MODIAN_ARRAY.append(modian)
modian_handler.taoba_project_array = global_config.MODIAN_ARRAY
# modian_handler.init_order_queues()
modian_handler.card_draw_handler.read_config()
global_config.JIZI_NOTIFY_GROUPS = ConfigReader.get_property(
'qq_conf', 'jizi_notify_groups').split(';')
modian_groups = global_config.JIZI_NOTIFY_GROUPS
modian_handler.group_account_notify_groups = modian_groups
my_logger.debug('JIZI_NOTIFY_GROUPS: %s, length: %d',
','.join(global_config.JIZI_NOTIFY_GROUPS),
len(modian_handler.group_account_notify_groups))
my_logger.debug('读取正在进行中的flag活动')
global_config.MODIAN_FLAG_ACTIVITIES = {}
flag_json = json.load(open('data/modian_flag.json',
encoding='utf8'))['activities']
for modian in global_config.MODIAN_ARRAY:
pro_id = modian.taoba_id
global_config.MODIAN_FLAG_ACTIVITIES[pro_id] = []
for activity in flag_json:
pro_id = activity['pro_id']
end_time = activity['end_time']
if util.convert_timestr_to_timestamp(end_time) > time.time():
flag = ModianFlagEntity(activity['flag_name'], activity['pro_id'],
activity['target_flag_amount'],
activity['end_time'], activity['remark'])
global_config.MODIAN_FLAG_ACTIVITIES[int(pro_id)].append(flag)
my_logger.debug('MODIAN_FLAG_ACTIVITIES: %s',
global_config.MODIAN_FLAG_ACTIVITIES)
my_logger.debug('读取正在进行的人头flag活动')
global_config.MODIAN_COUNT_FLAG_ACTIVITIES = {}
count_flag_json = json.load(
open('data/modian_count_flag.json', encoding='utf8'))['activities']
for modian in global_config.MODIAN_ARRAY:
pro_id = modian.taoba_id
global_config.MODIAN_COUNT_FLAG_ACTIVITIES[pro_id] = []
for activity in count_flag_json:
pro_id = activity['pro_id']
start_time = activity['start_time']
end_time = activity['end_time']
if util.convert_timestr_to_timestamp(
start_time) >= util.convert_timestr_to_timestamp(end_time):
my_logger.error('人头类flag，起始时间大于结束时间！')
raise RuntimeError('起始时间大于结束时间')
time0 = time.time()
if util.convert_timestr_to_timestamp(
end_time) > time0 > util.convert_timestr_to_timestamp(
start_time):
flag = ModianCountFlagEntity(activity['flag_name'],
activity['pro_id'],
activity['target_flag_amount'],
activity['start_time'],
activity['end_time'],
activity['remark'])
global_config.MODIAN_COUNT_FLAG_ACTIVITIES[int(pro_id)].append(
flag)
my_logger.debug('MODIAN_COUNT_FLAG_ACTIVITIES: %s',
global_config.MODIAN_COUNT_FLAG_ACTIVITIES)
# 接棒活动更新，读取json文件中的内容，更新到数据库中
my_logger.debug('接棒活动更新，读取json文件中的内容，更新到数据库中')
jiebang_json = json.load(open('data/modian_jiebang.json',
encoding='utf8'))['activities']
# conn = sqlite3.connect('data/modian.db', check_same_thread=False)
for activity in jiebang_json:
end_time = activity['end_time']
my_logger.debug('活动结束时间: {}; 当前时间：{}'.format(
util.convert_timestr_to_timestamp(end_time), time.time()))
if util.convert_timestr_to_timestamp(end_time) < time.time():
my_logger.debug('活动结束时间早于当前时间，跳过')
continue
name = activity['jiebang_name']
try:
# cursor = conn.cursor()
# c = cursor.execute("""
# select * from jiebang WHERE name=?
# """, (name, ))
# rst = c.fetchall()
rst = mysql_util.select_one(
"""
select * from jiebang WHERE name=%s
""", (name, ))
my_logger.debug(rst)
if rst is not None:
my_logger.debug('DB中有相应的接棒活动')
else:
my_logger.debug('DB中没有对应的接棒活动，需要创建')
mysql_util.query(
"""
INSERT INTO jiebang (name, pro_id, current_stick_num, start_time,
end_time, target_stick_num, min_stick_amount, need_detail) VALUES
(%s, %s, %s, %s, %s, %s, %s, %s)
""",
(name, activity['pro_id'], 0, activity['start_time'],
activity['end_time'], activity['target_stick_num'],
activity['min_stick_amount'], activity['need_detail']))
# conn.commit()
# else:
# raise RuntimeError('接棒活动名称错误！')
except Exception as e:
my_logger.error('读取mysql出现错误')
my_logger.exception(e)
# finally:
# cursor.close()
# 读取正在进行中的接棒活动
my_logger.debug('读取正在进行中的接棒活动')
global_config.MODIAN_JIEBANG_ACTIVITIES = {}
for modian in global_config.MODIAN_ARRAY:
pro_id = modian.taoba_id
global_config.MODIAN_JIEBANG_ACTIVITIES[pro_id] = []
try:
# cursor = conn.cursor()
rst = mysql_util.select_all(
"""
SELECT name, pro_id, current_stick_num, last_record_time,
start_time, end_time, target_stick_num, min_stick_amount, need_detail
FROM jiebang where pro_id=%s
and end_time >= NOW() and current_stick_num < target_stick_num
""", (pro_id, ))
if rst:
for jiebang in rst:
my_logger.debug('jiebang name: {}'.format(
str(jiebang[0], encoding='utf-8')))
# 修正当前棒数
my_logger.info('修正接棒棒数')
real_stick_num = 0
rst0 = mysql_util.select_all(
"""
SELECT backer_money FROM `order`
WHERE pro_id = %s and backer_money >= %s and pay_time >= %s and pay_time <= %s
""",
(pro_id, jiebang[7], jiebang[4], jiebang[5]))
my_logger.debug(
"""
SELECT backer_money FROM `order`
WHERE pro_id = %s and backer_money >= %s and pay_time >= %s and pay_time <= %s
""" %
(pro_id, jiebang[7], jiebang[4], jiebang[5]))
my_logger.debug(rst0)
if rst0:
for order in rst0:
my_logger.debug('order: {}'.format(order[0]))
real_stick_num += int(order[0] // jiebang[7])
my_logger.info('记录棒数: {}, 实际棒数: {}'.format(
jiebang[2], real_stick_num))
mysql_util.query(
"""
UPDATE jiebang SET current_stick_num = %s WHERE name = %s
""", (real_stick_num, jiebang[0]))
my_logger.debug(
'jiebang: %s, %s, %s, %s, %s, %s, %s, %s, %s',
jiebang[0], jiebang[1], jiebang[2], jiebang[3],
jiebang[4], jiebang[5], jiebang[6], jiebang[7],
jiebang[8])
jiebang_entity = ModianJiebangEntity(
str(jiebang[0], encoding='utf-8'), jiebang[1],
jiebang[2], jiebang[3], jiebang[4], jiebang[5],
jiebang[6], jiebang[7], jiebang[8])
jiebang_entity.current_stick_num = real_stick_num
my_logger.info('修正完成')
global_config.MODIAN_JIEBANG_ACTIVITIES[pro_id].append(
jiebang_entity)
except Exception as e:
my_logger.error('读取正在进行中的接棒活动出现错误！')
my_logger.exception(e)
# finally:
# cursor.close()
my_logger.debug(global_config.MODIAN_JIEBANG_ACTIVITIES)
# conn.close()
my_logger.debug('读取摩点配置耗时: %s秒', time.time() - time0)
modian_handler.init_order_queues()
def parse_order_details(self, orders, taoba_entity):
my_logger.debug('taoba_entity: {}'.format(taoba_entity.taoba_id))
my_logger.debug('keys: {}'.format(self.order_queues.keys()))
if len(self.order_queues[taoba_entity.taoba_id]) == 0 and len(
orders) == 0:
my_logger.debug('订单队列为空')
return
jiebang_activities = global_config.MODIAN_JIEBANG_ACTIVITIES[
taoba_entity.taoba_id]
flag_activities = global_config.MODIAN_FLAG_ACTIVITIES[
taoba_entity.taoba_id]
count_flag_activities = global_config.MODIAN_COUNT_FLAG_ACTIVITIES[
taoba_entity.taoba_id]
# 查询集资情况
pro_name, current, backer_count = self.get_current_and_target(
taoba_entity)
project_info = '当前进度: %s元' % current
taoba_entity.current = current
taoba_entity.title = pro_name
# group_account_entity.target = target
taoba_entity.support_num = backer_count
my_logger.debug('size of order %s queue: %s', taoba_entity.taoba_id,
len(self.order_queues[taoba_entity.taoba_id]))
for order in orders:
user_id = order['userid']
nickname = order['nickname']
pay_time = util.convert_timestamp_to_timestr(order['addtime'] *
1000)
single_price = order['amount']
pay_amount = order['nums']
backer_money = single_price
listid = int(order['id'])
my_logger.debug('oid: %s', listid)
if listid in self.order_queues[taoba_entity.taoba_id]:
continue
my_logger.debug('项目%s队列长度: %s', taoba_entity.taoba_id,
len(self.order_queues[taoba_entity.taoba_id]))
# 每次需要更新一下昵称
try:
mysql_util.query(
"""
INSERT INTO `supporter` (`id`, `name`) VALUES (%s, %s) ON DUPLICATE KEY
UPDATE `id`=%s
""", (user_id, nickname, user_id))
except Exception as e:
my_logger.exception(e)
try:
# 创建对象
mysql_util.query(
"""
INSERT INTO `order` (`id`,`supporter_id`,`backer_money`,`pay_time`, `pro_id`)
VALUES (%s, %s, %s, %s, %s) ON DUPLICATE KEY
UPDATE `id`=%s
""",
(str(listid), user_id, backer_money, pay_time,
taoba_entity.taoba_id, str(listid)))
except Exception as e:
my_logger.exception(e)
msg = '感谢 %s(%s) 支持了%s元, %s\n' % (
nickname, user_id, backer_money,
util.random_str(global_config.MODIAN_POSTSCRIPTS))
# daka_rank, support_days = self.find_user_daka_rank(user_id, group_account_entity.pro_id)
# if daka_rank != -1 and support_days:
# msg += '当前项目已打卡%s天\n' % support_days
# if group_account_entity.need_display_rank is True:
# jizi_rank, backer_money = self.find_user_jizi_rank(user_id, group_account_entity.pro_id)
# if jizi_rank != -1:
# msg += '当前项目已集资%s元, 排名: %s' % (backer_money, jizi_rank)
# else:
# pass
# 统计当前人数
count = mysql_util.select_one(
"""
SELECT COUNT(distinct(`supporter_id`)) FROM `order` WHERE `pro_id`=%s
""", (taoba_entity.taoba_id, ))
backer_count = count[0]
msg += '当前集资人数: %s\n' % backer_count
# 抽卡播报
card_report = ''
if global_config.MODIAN_CARD_DRAW:
card_report = self.card_draw_handler.draw(
user_id, nickname, backer_money, pay_time)
'''接棒相关'''
my_logger.debug('接棒情况更新')
for jiebang in jiebang_activities:
# if jiebang.start_time > time.time():
# continue
my_logger.debug('接棒活动详情: 【%s】', jiebang.name)
my_logger.debug('集资金额: %s, 接棒最小金额: %s', backer_money,
jiebang.min_stick_amount)
if backer_money >= jiebang.min_stick_amount:
stick_num = util.compute_stick_num(
jiebang.min_stick_amount, backer_money)
jiebang.current_stick_num += stick_num
jiebang.last_record_time = util.convert_timestamp_to_timestr(
int(time.time() * 1000))
# 数据库也要更新
try:
mysql_util.query(
"""
UPDATE jiebang SET `current_stick_num`=%s, `last_record_time`=%s WHERE `name`=%s
""", (jiebang.current_stick_num,
jiebang.last_record_time, jiebang.name))
except Exception as e:
my_logger.error('更新接棒数据失败')
my_logger.exception(e)
my_logger.debug('数据库接棒数据更新完成')
test_msg = ''
if jiebang.need_detail == 1:
test_msg = '【%s】, 当前第%s棒, 目标%s棒\n' \
% (jiebang.name, jiebang.current_stick_num, jiebang.target_stick_num)
elif jiebang.need_detail == 0:
test_msg = '【%s】\n' % jiebang.name
elif jiebang.need_detail == 2:
test_msg = '【%s】, 当前第%s棒\n' \
% (jiebang.name, jiebang.current_stick_num)
elif jiebang.need_detail == 3:
if stick_num > 1:
test_msg = '抽奖号: {}~{}\n'.format(
jiebang.current_stick_num - stick_num + 1,
jiebang.current_stick_num)
else:
test_msg = '抽奖号: {}\n'.format(
jiebang.current_stick_num)
my_logger.debug(test_msg)
if len(test_msg) > 0:
msg += test_msg
# QQHandler.send_to_groups(['483548995'], test_msg)
'''金额类flag相关'''
my_logger.debug('flag情况更新')
flag_test_msgs = ''
for flag in flag_activities:
my_logger.debug('Flag活动详情: %s', flag.name)
my_logger.debug('Flag金额: %s, 结束时间: %s',
flag.target_flag_amount, flag.end_time)
diff = flag.target_flag_amount - current
test_msgs = '【%s】, 目标金额: %s元, ' % (flag.name,
flag.target_flag_amount)
if diff > 0:
test_msgs += '距离目标还差%s元\n' % round(diff, 2)
flag_test_msgs += test_msgs
else:
test_msgs += '已经达成目标\n'
my_logger.debug(flag_test_msgs)
if len(flag_test_msgs) > 0:
pass
# QQHandler.send_to_groups(['483548995'], flag_test_msgs)
# msg += flag_test_msgs
'''人头类flag相关'''
my_logger.debug('人头flag情况更新')
count_flag_test_msgs = ''
for flag in count_flag_activities:
my_logger.debug('人头Flag活动详情: %s', flag.name)
my_logger.debug('人头Flag目标: %s, 开始时间: %s, 结束时间: %s',
flag.target_flag_amount, flag.start_time,
flag.end_time)
target = flag.target_flag_amount
# 统计当前人数
rst = mysql_util.select_one(
"""
select count(distinct(`supporter_id`)) from `order`
where `pro_id` = %s and `pay_time` <= %s and `pay_time` >= %s
""", (taoba_entity.taoba_id, flag.end_time, flag.start_time))
# 目标人数为0，代表特殊类flag，只报人数
if target == 0:
count_flag_test_msgs += '【%s】, 当前人数: %s ' % (flag.name,
rst[0])
else:
count_flag_test_msgs += '【%s】, 当前人数: %s, 目标人数: %s ' % (
flag.name, rst[0], flag.target_flag_amount)
my_logger.debug(count_flag_test_msgs)
if len(count_flag_test_msgs) > 0:
# QQHandler.send_to_groups(['483548995'], count_flag_test_msgs)
pass
# msg += flag_test_msgs
msg += '%s\n集资项目: %s\n集资方式: %s\n' % (project_info, pro_name,
taoba_entity.link)
# msg += jizi_pk_report
# if global_config.MODIAN_NEED_DISPLAY_PK:
# msg += self.pk_modian_activity()
if global_config.USING_COOLQ_PRO is True:
my_logger.debug('使用酷Q PRO发送图片')
msg += '\n[CQ:image,file={}]\n'.format(taoba_entity.qrcode)
# QQHandler.send_to_groups(taoba_entity.broadcast_groups, msg)
if card_report:
pass
# QQHandler.send_to_groups(taoba_entity.broadcast_groups, card_report)
# QQHandler.send_to_groups(['483548995'], card_report)
# 集五福
# wufu_report = modian_wufu_handler.draw(user_id, nickname, backer_money, pay_time)
# if wufu_report:
# QQHandler.send_to_groups(group_account_entity.broadcast_groups, wufu_report)
self.order_queues[taoba_entity.taoba_id].add(listid)
# 更新接棒的数据库
try:
my_logger.debug('更新接棒活动信息:')
for jiebang in jiebang_activities:
my_logger.debug(
'current_stick_num: %s, last_record_time: %s, name: %s',
jiebang.current_stick_num, jiebang.last_record_time,
jiebang.name)
mysql_util.query(
"""
UPDATE jiebang SET current_stick_num=%s WHERE name=%s
""", (jiebang.current_stick_num, jiebang.name))
except Exception as e:
my_logger.exception(e)
def get_cards(self, modian_id):
"""
获取该人所有已抽中的卡
:param modian_id:
:return:
"""
logger.info("查询已抽中的卡: {}".format(modian_id))
rst = mysql_util.select_all("""
select card_id, count(*) from `draw_record` where supporter_id=%s group by `card_id`;
""", (modian_id,))
rst_level = {}
rst_level[CardLevel.UR] = []
rst_level[CardLevel.SSR] = []
rst_level[CardLevel.SR] = []
rst_level[CardLevel.R] = []
rst_num = {}
type_dict = {
# CardType.STAR: '星组',
# CardType.MOON: '月组',
# CardType.SUN: '日组',
CardType.NORMAL: '普通',
CardType.SPECIAL: '活动限定',
}
if rst and len(rst) > 0:
logger.debug(rst)
for tmp in rst:
card = self.cards_single[int(tmp[0])]
if card not in rst_level[card.level]:
rst_level[card.level].append(card)
else:
return '桃叭ID: {}, 当前暂未抽中任何卡片 \n'.format(modian_id)
logger.debug(rst_level)
logger.debug(rst_num)
self.generate_card_pic(rst_level, modian_id)
report = '桃叭ID: {}, 当前已抽中的卡片有: \n'.format(modian_id)
if CardLevel.UR in rst_level and len(rst_level[CardLevel.UR]) > 0:
report += '【UR】({}/{}): '.format(len(rst_level[CardLevel.UR]), len(self.all_cards[CardLevel.UR]))
for card in rst_level[CardLevel.UR]:
# report += '{}-{}, '.format(type_dict[card.type0], card.name)
report += '{}, '.format(card.name)
report += '\n'
logger.debug(report)
if CardLevel.SSR in rst_level and len(rst_level[CardLevel.SSR]) > 0:
report += '【SSR】({}/{}): '.format(len(rst_level[CardLevel.SSR]), len(self.all_cards[CardLevel.SSR]))
for card in rst_level[CardLevel.SSR]:
# report += '{}-{}, '.format(type_dict[card.type0], card.name)
report += '{}, '.format(card.name)
report += '\n'
logger.debug(report)
if CardLevel.SR in rst_level and len(rst_level[CardLevel.SR]) > 0:
report += '【SR】({}/{}): '.format(len(rst_level[CardLevel.SR]), len(self.all_cards[CardLevel.SR]))
for card in rst_level[CardLevel.SR]:
# report += '{}{}, '.format(type_dict[card.type0], card.sub_id)
report += '{}, '.format(card.name)
report += '\n'
if CardLevel.R in rst_level and len(rst_level[CardLevel.R]) > 0:
report += '【R】({}/{}): '.format(len(rst_level[CardLevel.R]), len(self.all_cards[CardLevel.R]))
for card in rst_level[CardLevel.R]:
# report += '{}{}, '.format(type_dict[card.type0], card.sub_id)
report += '{}, '.format(card.name)
report += '\n'
current_score = self.get_current_score(modian_id)
report += '当前积分为: {}\n'.format(current_score)
logger.debug(report)
return report
def draw(self, user_id, nickname, backer_money, pay_time):
logger.info('抽卡: user_id: %s, nickname: %s, backer_money: %s, pay_time: %s',
user_id, nickname, backer_money, pay_time)
# 计算抽卡张数
card_num = self.compute_draw_nums(backer_money)
if card_num == 0:
logger.info('集资未达到标准，无法抽卡')
return ''
logger.info('共抽卡%d张', card_num)
rst = {}
rst_type = {}
rst_level = {}
level_list = [CardLevel.R, CardLevel.SR, CardLevel.SSR, CardLevel.UR]
type_dict = {
# CardType.STAR: '星组',
# CardType.MOON: '月组',
# CardType.SUN: '日组',
CardType.NORMAL: '普通',
CardType.SPECIAL: '活动限定'
}
# 获取此ID已抽中的全部卡牌
rst_tmp = mysql_util.select_all("""
SELECT distinct(`card_id`) from `draw_record` where supporter_id="%s"
""", (user_id,))
card_has = set() # 该用户已经拥有的卡片
card_new = set() # 该用户收集到的新卡
if rst_tmp and len(rst_tmp) > 0:
for tmp in rst_tmp:
card_has.add(tmp[0])
logger.debug('摩点ID: {}, 当前拥有的卡片: {}'.format(user_id, card_has))
score_add = 0
insert_sql = 'INSERT INTO `draw_record` (`supporter_id`, `card_id`, `draw_time`, `backer_money`) VALUES '
flag = False
for no in range(card_num):
# 先判断能否抽中卡，如果抽不中，直接跳过
# draw_rst = self.can_draw()
# if not draw_rst:
# continue
flag = True
# 卡片类型
idx = util.weight_choice(level_list, self.weights)
card_type = level_list[idx]
# 在对应卡片类型中，抽出一张卡
card = util.choice(self.cards[card_type])[0]
logger.debug('抽出的卡: %s' % card)
if card.id in card_has:
logger.debug('卡片{}已经拥有，积分+1')
# 如果已经拥有该卡片，积分+1
score_add += 1
else:
card_new.add(card.id)
card_has.add(card.id)
# card = self.base_cards[card_index]
insert_sql += """("%s", %s, '%s', %s),""" % (user_id, card.id, pay_time, backer_money)
# 此种类型的卡如果已经达到了1张，则将该卡片从卡池中移除
# if card.id in ACTIVITY_CARD_ID:
# rst2 = mysql_util.select_one("""
# SELECT count(*) from `draw_record` WHERE `card_id` = %s
# """, (card.id,))
# if rst2:
# if rst2[0] == 1:
# if card in self.cards[card.level]:
# self.cards[card.level].remove(card)
if card in rst:
rst[card] += 1
else:
rst[card] = 1
if card.level not in rst_level:
rst_level[card.level] = []
if card not in rst_level[card.level]:
rst_level[card.level].append(card)
if card.type0 not in rst_type:
rst_type[card.type0] = []
if card not in rst_type[card.type0]:
rst_type[card.type0].append(card)
print(insert_sql[:-1])
logger.debug(insert_sql[:-1])
logger.debug('摩点ID: {}, 抽到的新卡片: {}'.format(user_id, card_new))
img_flag = True
img_report = ''
report = '恭喜抽中:\n'
card_new_list = [] # 用来发图的
if CardLevel.UR in rst_level and len(rst_level[CardLevel.UR]) > 0:
report += '【UR】: '
for card in rst_level[CardLevel.UR]:
# report += '{}-{}*{}, '.format(type_dict[card.type0], card.name, rst[card])
new_flag = ''
if card.id in card_new:
new_flag = emojis.encode('(:new:)')
card_new_list.append(self.cards_single[card.id])
report += '{}*{}{}, '.format(card.name, rst[card], new_flag)
if img_flag:
if len(card_new_list) > 0:
img = util.choice(card_new_list)[0]
else:
img = util.choice(rst_level[CardLevel.UR])[0]
img_report = '[CQ:image,file={}]\n'.format(img.url)
img_flag = False
report += '\n'
if CardLevel.SSR in rst_level and len(rst_level[CardLevel.SSR]) > 0:
report += '【SSR】: '
for card in rst_level[CardLevel.SSR]:
# report += '{}-{}*{}, '.format(type_dict[card.type0], card.name, rst[card])
new_flag = ''
if card.id in card_new:
new_flag = emojis.encode('(:new:)')
card_new_list.append(self.cards_single[card.id])
report += '{}*{}{}, '.format(card.name, rst[card], new_flag)
if img_flag:
if len(card_new_list) > 0:
img = util.choice(card_new_list)[0]
else:
img = util.choice(rst_level[CardLevel.SSR])[0]
img_report = '[CQ:image,file={}]\n'.format(img.url)
img_flag = False
report += '\n'
if CardLevel.SR in rst_level and len(rst_level[CardLevel.SR]) > 0:
report += '【SR】: '
for card in rst_level[CardLevel.SR]:
# report += '{}{}*{}, '.format(type_dict[card.type0], card.sub_id, rst[card])
# report += '{}-{}*{}, '.format(type_dict[card.type0], card.name, rst[card])
new_flag = ''
if card.id in card_new:
new_flag = emojis.encode('(:new:)')
card_new_list.append(self.cards_single[card.id])
report += '{}*{}{}, '.format(card.name, rst[card], new_flag)
if img_flag:
if len(card_new_list) > 0:
img = util.choice(card_new_list)[0]
else:
img = util.choice(rst_level[CardLevel.SR])[0]
img_report = '[CQ:image,file={}]\n'.format(img.url)
img_flag = False
report += '\n'
if CardLevel.R in rst_level and len(rst_level[CardLevel.R]) > 0:
report += '【R】: '
for card in rst_level[CardLevel.R]:
# report += '{}{}*{}, '.format(type_dict[card.type0], card.sub_id, rst[card])
# report += '{}-{}*{}, '.format(type_dict[card.type0], card.name, rst[card])
new_flag = ''
if card.id in card_new:
new_flag = emojis.encode('(:new:)')
card_new_list.append(self.cards_single[card.id])
report += '{}*{}{}, '.format(card.name, rst[card], new_flag)
if img_flag:
if len(card_new_list) > 0:
img = util.choice(card_new_list)[0]
else:
img = util.choice(rst_level[CardLevel.R])[0]
img_report = '[CQ:image,file={}]\n'.format(img.url)
img_flag = False
report += '\n'
report += img_report
if flag: # 如果一张都没有抽中，就不执行sql语句
mysql_util.query(insert_sql[:-1])
# 积分保存到数据库
if score_add > 0:
mysql_util.query("""
INSERT INTO `t_card_score` (`modian_id`, `score`) VALUES
(%s, %s)
""", (user_id, score_add))
report += '通过重复卡获取积分: {}\n'.format(score_add)
report += '当前积分为: {}\n'.format(self.get_current_score(user_id))
logger.debug(report)
return report
def parse_order_details(self, orders, modian_entity):
if len(self.order_queues[modian_entity.pro_id]) == 0 and len(
orders) == 0:
my_logger.debug('订单队列为空')
return
jiebang_activities = global_config.MODIAN_JIEBANG_ACTIVITIES[
modian_entity.pro_id]
flag_activities = global_config.MODIAN_FLAG_ACTIVITIES[
modian_entity.pro_id]
count_flag_activities = global_config.MODIAN_COUNT_FLAG_ACTIVITIES[
modian_entity.pro_id]
# 查询集资情况
target, current, pro_name, backer_count = self.get_current_and_target(
modian_entity)
project_info = '当前进度: %s元, 目标金额: %s元' % (current, target)
modian_entity.current = current
modian_entity.title = pro_name
modian_entity.target = target
modian_entity.support_num = backer_count
my_logger.debug('size of order %s queue: %s', modian_entity.pro_id,
len(self.order_queues[modian_entity.pro_id]))
for order in orders:
user_id = order['user_id']
nickname = order['nickname']
pay_time = order['pay_time']
backer_money = order['backer_money']
oid = uuid.uuid3(uuid.NAMESPACE_OID, str(user_id) + pay_time)
my_logger.debug('oid: %s', oid)
if oid in self.order_queues[modian_entity.pro_id]:
continue
my_logger.debug('项目%s队列长度: %s', modian_entity.pro_id,
len(self.order_queues[modian_entity.pro_id]))
# 每次需要更新一下昵称
try:
# supporter = Supporter(id=user_id, name=nickname)
# self.alchemy_session.merge(supporter)
mysql_util.query(
"""
INSERT INTO `supporter` (`id`, `name`) VALUES (%s, %s) ON DUPLICATE KEY
UPDATE `name`=%s
""", (user_id, nickname, nickname))
except Exception as e:
my_logger.exception(e)
try:
# 创建对象
# modian_order = ModianOrder(id=str(oid), supporter_id=user_id, backer_money=backer_money, pay_time=pay_time,
# pro_id=modian_entity.pro_id)
# self.alchemy_session.merge(modian_order)
mysql_util.query(
"""
INSERT INTO `order` (`id`,`supporter_id`,`backer_money`,`pay_time`, `pro_id`)
VALUES (%s, %s, %s, %s, %s) ON DUPLICATE KEY
UPDATE `id`=%s
""",
(str(oid), user_id, backer_money, pay_time,
modian_entity.pro_id, str(oid)))
except Exception as e:
my_logger.exception(e)
msg = '感谢 %s(%s) 支持了%s元, %s\n' % (
nickname, user_id, backer_money,
util.random_str(global_config.MODIAN_POSTSCRIPTS))
daka_rank, support_days = self.find_user_daka_rank(
user_id, modian_entity.pro_id)
if daka_rank != -1 and support_days:
msg += '当前项目已打卡%s天\n' % support_days
if modian_entity.need_display_rank is True:
jizi_rank, backer_money = self.find_user_jizi_rank(
user_id, modian_entity.pro_id)
if jizi_rank != -1:
msg += '当前项目已集资%s元, 排名: %s' % (backer_money, jizi_rank)
else:
pass
# 统计当前人数
msg += '当前集资人数: %s\n' % backer_count
# 抽卡播报
card_report = ''
if global_config.MODIAN_CARD_DRAW:
card_report = self.card_draw_handler.draw(
user_id, nickname, backer_money, pay_time)
'''接棒相关'''
my_logger.debug('接棒情况更新')
for jiebang in jiebang_activities:
# if jiebang.start_time > time.time():
# continue
my_logger.debug('接棒活动详情: 【%s】', jiebang.name)
my_logger.debug('集资金额: %s, 接棒最小金额: %s', backer_money,
jiebang.min_stick_amount)
if backer_money >= jiebang.min_stick_amount:
stick_num = util.compute_stick_num(
jiebang.min_stick_amount, backer_money)
jiebang.current_stick_num += stick_num
jiebang.last_record_time = util.convert_timestamp_to_timestr(
int(time.time() * 1000))
# 数据库也要更新
try:
mysql_util.query(
"""
UPDATE jiebang SET `current_stick_num`=%s, `last_record_time`=%s WHERE `name`=%s
""", (jiebang.current_stick_num,
jiebang.last_record_time, jiebang.name))
except Exception as e:
my_logger.error('更新接棒数据失败')
my_logger.exception(e)
my_logger.debug('数据库接棒数据更新完成')
test_msg = ''
if jiebang.need_detail == 1:
test_msg = '【%s】, 当前第%s棒, 目标%s棒\n' \
% (jiebang.name, jiebang.current_stick_num, jiebang.target_stick_num)
elif jiebang.need_detail == 0:
test_msg = '【%s】\n' % jiebang.name
elif jiebang.need_detail == 2:
test_msg = '【%s】, 当前第%s棒\n' \
% (jiebang.name, jiebang.current_stick_num)
elif jiebang.need_detail == 3:
if stick_num > 1:
test_msg = '抽奖号: {}~{}\n'.format(
jiebang.current_stick_num - stick_num + 1,
jiebang.current_stick_num)
else:
test_msg = '抽奖号: {}\n'.format(
jiebang.current_stick_num)
my_logger.debug(test_msg)
if len(test_msg) > 0:
msg += test_msg
QQHandler.send_to_groups(['483548995'], test_msg)
'''金额类flag相关'''
my_logger.debug('flag情况更新')
flag_test_msgs = ''
for flag in flag_activities:
my_logger.debug('Flag活动详情: %s', flag.name)
my_logger.debug('Flag金额: %s, 结束时间: %s',
flag.target_flag_amount, flag.end_time)
diff = flag.target_flag_amount - current
test_msgs = '【%s】, 目标金额: %s元, ' % (flag.name,
flag.target_flag_amount)
if diff > 0:
test_msgs += '距离目标还差%s元\n' % round(diff, 2)
flag_test_msgs += test_msgs
else:
test_msgs += '已经达成目标\n'
my_logger.debug(flag_test_msgs)
if len(flag_test_msgs) > 0:
QQHandler.send_to_groups(['483548995'], flag_test_msgs)
# msg += flag_test_msgs
'''人头类flag相关'''
my_logger.debug('人头flag情况更新')
count_flag_test_msgs = ''
for flag in count_flag_activities:
my_logger.debug('人头Flag活动详情: %s', flag.name)
my_logger.debug('人头Flag目标: %s, 开始时间: %s, 结束时间: %s',
flag.target_flag_amount, flag.start_time,
flag.end_time)
target = flag.target_flag_amount
# 统计当前人数
rst = mysql_util.select_one(
"""
select count(distinct(`supporter_id`)) from `order`
where `pro_id` = %s and `pay_time` <= %s and `pay_time` >= %s
""", (modian_entity.pro_id, flag.end_time, flag.start_time))
# 目标人数为0，代表特殊类flag，只报人数
if target == 0:
count_flag_test_msgs += '【%s】, 当前人数: %s ' % (flag.name,
rst[0])
else:
count_flag_test_msgs += '【%s】, 当前人数: %s, 目标人数: %s ' % (
flag.name, rst[0], flag.target_flag_amount)
my_logger.debug(count_flag_test_msgs)
if len(count_flag_test_msgs) > 0:
QQHandler.send_to_groups(['483548995'], count_flag_test_msgs)
# msg += flag_test_msgs
msg += '%s\n集资项目: %s\n链接: %s\n' % (project_info, pro_name,
modian_entity.link)
# msg += jizi_pk_report
my_logger.info(msg)
if global_config.USING_COOLQ_PRO is True:
my_logger.debug('使用酷Q PRO发送图片')
msg += '\n[CQ:image,file=http://wx1.sinaimg.cn/large/439a9f3fgy1fpllweknr6j201i01g0lz.jpg]\n'
# if global_config.MODIAN_NEED_DISPLAY_PK:
# msg += self.pk_modian_activity()
QQHandler.send_to_groups(modian_entity.broadcast_groups, msg)
if card_report:
QQHandler.send_to_groups(modian_entity.broadcast_groups,
card_report)
# QQHandler.send_to_groups(['483548995'], card_report)
self.order_queues[modian_entity.pro_id].add(oid)
# 更新接棒的数据库
try:
my_logger.debug('更新接棒活动信息:')
for jiebang in jiebang_activities:
my_logger.debug(
'current_stick_num: %s, last_record_time: %s, name: %s',
jiebang.current_stick_num, jiebang.last_record_time,
jiebang.name)
mysql_util.query(
"""
UPDATE jiebang SET current_stick_num=%s WHERE name=%s
""", (jiebang.current_stick_num, jiebang.name))
except Exception as e:
my_logger.exception(e)
