def _execute(self):
data = self._data
# リクエストパラメーターチェック
if self._is_validate_parameters(data) == False:
self._request_handler.response({'res': False, 'status': 'hacking'})
return
war_id = data['war_id']
team_id = data['team_id']
if not war_id or not team_id:
self._request_handler.response({'res': False, 'status': 'error'})
return
# 敵チームを取得
redis_war = RedisWarData()
enemy_team_data = redis_war.get_enemy_data(war_id, team_id,
get_serial_date())
if enemy_team_data['type'] == 'error':
self._request_handler.response({
'res': False,
'status': enemy_team_data['status']
})
return
enemy_user_list = enemy_team_data['data']['parent']
enemy_team_id = enemy_user_list[0]['team_id']
# 自チーム情報を取得
myself_team_data = redis_war.get_enemy_data(war_id, enemy_team_id,
get_serial_date())
if myself_team_data['type'] == 'error':
self._request_handler.response({
'res': False,
'status': myself_team_data['status']
})
return
self._request_handler.response({
'res':
True,
'data':
self.__convert_client_response(myself_team_data['data'],
enemy_team_data['data'])
})
def set_user_exp_up_campaign(self, user_data_model, user_ids, is_win):
now_datetime = get_now_datetime()
now_time = get_serial_date()
using_data = user_data_model.get_enable_protein_effect(user_ids)
effect_time = 0
if is_win:
effect_time = self.__war_win_exp_up_campaign_time
else:
effect_time = self.__war_lose_exp_up_campaign_time
using_ids = []
insert_data = []
# 既に使用中のユーザは終了直後に発動
for row in using_data:
using_ids.append(int(row['user_id']))
insert_data.append([row['user_id'], row['end_time'], row['end_time'] + effect_time, now_date])
for user_id in user_ids:
if int(user_id) in using_ids:
continue
insert_data.append([user_id, now_time, now_time + effect_time, now_datetime])
# プロテイン効果を登録
user_data_model.insert_protein_effect(user_ids, insert_data)
def __check_war_end_countdown(self, war_id, team_id):
redis_war = RedisWarData()
result = redis_war.war_get_end_countdown(war_id)
if result['type'] != 'ok':
return
# 抗争終了カウントダウンチェック
countdown_data = result['data']
if countdown_data[0] == '1':
start_time = int(countdown_data[1])
remain_time = END_COUNTDOWN_TIME - (get_serial_date() - start_time)
if remain_time < 0:
remain_time = 0
# 抗争終了処理を実行
lose_team_id = countdown_data[3]
self._socket_handler.send_message_to_myself({
'war_id': war_id,
'team_id': team_id,
'result': {
'death_team_id': lose_team_id,
'rest_seconds': remain_time,
},
})
def war_get_end_countdown(self, war_id):
key = '{0}:'.format(war_id)
sha = 'kkkkkac706df7e51da5521d4bde31e80ddbeb60'
lua_file_name = 'WarGetEndCountdown.lua'
sha = self._load_lua_script(lua_file_name, sha)
return msgpack.unpackb(
self._redis.evalsha(sha, 1, key, get_serial_date()))
def _pre_execute(self):
redis_war = RedisWarData()
result = redis_war.war_get_end_countdown(self._socket_handler._war_id)
if result['type'] != 'ok' or not hasattr(self._socket_handler,
'_war_id'):
return True
# 抗争終了カウントダウンチェック
countdown_data = result['data']
if countdown_data[0] == '1':
start_time = int(countdown_data[1])
remain_time = END_COUNTDOWN_TIME - (get_serial_date() - start_time)
if remain_time <= 0:
# カウントダウン処理終了
redis_war.war_end_countdown(self._socket_handler._war_id)
# 抗争終了処理を実行
war_result_logic = WarResultLogic()
win_team_id = countdown_data[2]
lose_team_id = countdown_data[3]
war_id = self._socket_handler._war_id
# 抗争終了時の参戦メンバーを取得
members = redis_war.get_end_member(war_id, win_team_id,
lose_team_id)
# 抗争結果登録
war_result_logic.regist_war_result(war_id,
win_team_id,
lose_team_id,
0,
members['win'],
members['lose'],
is_timeup=0)
self._socket_handler.send_message({
'war_id': war_id,
'team_id': win_team_id,
'finish': 'ok',
})
self._socket_handler.send_message({
'war_id': war_id,
'team_id': lose_team_id,
'finish': 'ok',
})
return False
return True
def _execute(self):
# リクエストパラメーターチェック
packet = PacketRegist(self._data)
if packet.is_validate_hash() == False:
return False
redis_war = RedisWarData()
result = redis_war.enter_war(packet.war_id,
packet.team_id,
packet.user_id,
get_serial_date(),
options.redis_war_data_expire)
if result['type'] == 'error':
self._socket_handler.send_message_to_myself({'regist': 'NG', 'status': result['status']})
return True
enemy_team_id = int(result['enemy_team_id'])
war_start_time = int(result['start_time'])
war_end_time = int(result['end_time'])
self.__regist_ws_client(packet, enemy_team_id, war_start_time, war_end_time)
self._socket_handler.send_message_to_myself({'regist': 'OK', 'enemy_team_id':enemy_team_id})
# 抗争終了カウントダウンチェック
countdown_data = result['countdown_data']
if countdown_data[0] == '1':
start_time = int(countdown_data[1])
remain_time = END_COUNTDOWN_TIME - (get_serial_date() - start_time)
if remain_time < 0:
remain_time = 0
self._socket_handler.send_message_to_myself({'result': {'death_team_id':countdown_data[3], 'rest_seconds':remain_time }})
return True
def get_enable_protein_effect(self, user_id_list):
user_id_count = len(user_id_list)
if user_id_count == 0:
return
now_time = get_serial_date()
format_strings = ','.join(['%s'] * user_id_count)
sql = 'select id, user_id, effect, open_time, end_time from protein_status where user_id in (' + format_strings + ') and open_time <= %s and end_time >= %s'
self._db.execute(sql, tuple(user_id_list) + (now_time, now_time))
return self._db.fetchall()
def get_successive_victory_present_list(self, user_data_list,
prize_data_list, victory_count):
now_datetime = get_now_datetime()
now_time = get_serial_date()
present_list = []
for prize in prize_data_list:
for user_data in user_data_list:
present_list.append(
(user_data['id'], prize['item_type'], prize['item_id'],
self.get_victory_prize_message(victory_count),
prize['quantity'], now_time, now_datetime))
return present_list
def get_win_present_list(self, user_id_list, result_data):
now_datetime = get_now_datetime()
now_time = get_serial_date()
present_list = []
if len(user_id_list) == 0:
return present_list
prize_data_list = json.loads(result_data['get_item'])
for user_id in user_id_list:
for win_item in prize_data_list:
present_list.append(
(user_id, int(win_item['item_type']),
int(win_item['item_id']), self.get_win_present_message(),
int(win_item['quantity']), now_time, now_datetime))
return present_list
def on_close(self):
try:
if not hasattr(self, '_war_id') or not hasattr(self, '_user_id'):
return
# SocketHandler登録削除
app_instance = AppServer.AppServer()
app_instance.unregist_ws_client(self._war_id, self)
redis_war = RedisWarData()
# 退出によりターゲットを解除を通知
select_enemy = redis_war.select_enemy(
self._war_id, self._team_id, self._user_id, self._user_name, 0,
get_serial_date(), options.redis_war_data_expire)
if select_enemy['status'] == 'ok':
send_data = {
'war_id': self._war_id,
'team_id': self._team_id,
'select': {
'status': 'ok',
'team_id': int(self._team_id),
'user_id': int(self._user_id),
'before_enemy': select_enemy['before_enemy'],
'after_enemy': select_enemy['after_enemy']
},
}
self.send_message(send_data)
# 退出によるデータ更新し、チームメンバーに通知する
redis_war.exit_war(self._war_id, self._user_id, self._team_id,
options.redis_war_data_expire)
#logging.info('[Socket close] user_id: ' + str(self._user_id))
except Exception as e:
import traceback
logging.error(e.message)
logging.error(traceback.format_exc())
def update_user_data(self,
war_id,
now_turn_number,
is_enemy_first,
team_id,
user_id,
player_action_type,
player_action_id,
player_action_hit,
player_do_damage,
enemy_team_id,
enemy_user_id,
enemy_action_type,
enemy_action_id,
enemy_action_hit,
enemy_do_damage):
key = '{0}:'.format(war_id)
sha = 'kkkkfd3b3977c7441783f258c322e0616c2835b'
lua_file_name = 'ActionAttack.lua'
sha = self._load_lua_script(lua_file_name, sha)
result = msgpack.unpackb(self._redis.evalsha(sha, 1, key,
now_turn_number,
is_enemy_first,
team_id,
user_id,
int(player_action_type),
int(player_action_id),
int(player_action_hit),
int(player_do_damage),
enemy_team_id,
enemy_user_id,
int(enemy_action_type),
int(enemy_action_id),
int(enemy_action_hit),
int(enemy_do_damage),
get_serial_date()))
return result
def _execute(self):
war_id = self._socket_handler._war_id
team_id = self._socket_handler._team_id
enemy_team_id = self._socket_handler._enemy_team_id
user_id = self._socket_handler._user_id
# 抗争終了時間を過ぎているかチェック
now_time = get_serial_date()
if now_time < self._socket_handler._war_end_time:
self.__check_war_end_countdown(war_id, team_id)
return True
war_result_logic = WarResultLogic()
# timeup
redis_war = RedisWarData()
result = redis_war.timeup_judge_win_team(war_id, team_id, enemy_team_id, options.redis_war_data_expire, random.choice(('0', '1')))
win_team_id = result['win']
lose_team_id = result['lose']
enemy_count = result['enemy_count']
finish_attack = result['finish_attack']
# タイムアップによる抗争勝敗を通知する
self.__send_win_or_lose_to_team(war_id, win_team_id, lose_team_id, finish_attack)
if result['type'] == 'timeup':
# 抗争終了時の参戦メンバーを取得
members = redis_war.get_end_member(war_id, win_team_id, lose_team_id)
# 抗争結果登録
war_result_logic.regist_war_result(war_id, win_team_id, lose_team_id, enemy_count, members['win'], members['lose'], is_timeup = 1)
# 抗争終了通知
self.__send_finish_to_team(war_id, win_team_id, lose_team_id)
return True
def update_lose_users_hp(self, team_id, hp):
sql = 'update user set hp = %s, hp_recovery_time = %s, is_dead = 0 where team_id = %s'
return self._db.execute(sql, (hp, get_serial_date(), team_id))
def _execute(self):
# リクエストパラメーターチェック
packet = PacketSelect(self._data)
if packet.is_validate_hash() == False:
return False
user_id = int(packet.user_id)
user_name = packet.user_name
enemy_user_id = int(packet.enemy_user_id)
enemy_team_id = self._socket_handler._enemy_team_id
war_id = self._socket_handler._war_id
team_id = self._socket_handler._team_id
redis_war = RedisWarData()
result = redis_war.select_enemy(war_id, team_id, user_id, user_name,
enemy_user_id, get_serial_date(),
options.redis_war_data_expire)
is_ok = True
if result['status'] == 'before_start':
is_ok = False
if result['status'] == 'is_dead':
is_ok = False
if is_ok:
# 全員に通知
self._socket_handler.send_message({
'war_id': war_id,
'team_id': team_id,
'select': {
'status': 'ok',
'team_id': team_id,
'user_id': user_id,
'user_name': user_name,
'before_enemy': result['before_enemy'],
'after_enemy': result['after_enemy']
},
})
self._socket_handler.send_message({
'war_id': war_id,
'team_id': enemy_team_id,
'select': {
'status': 'ok',
'team_id': team_id,
'user_id': user_id,
'user_name': user_name,
'before_enemy': result['before_enemy'],
'after_enemy': result['after_enemy']
},
})
else:
# 敵の選択に失敗したので自分にのみ, レスポンス
self._socket_handler.send_message_to_myself({
'war_id': war_id,
'team_id': team_id,
'select': {
'status': result['status'],
'user_id': user_id,
'user_name': user_name,
'enemy_user_id': enemy_user_id
},
})
return True
def use_item(self, war_id, team_id, user_id, item_category, use_item_id, item_category_id, target_id, heal_effect):
if item_category == ActionType.use_item_hp_heal:
key = '{0}:'.format(war_id)
sha = 'aaaaafd3b3977c7441783f258c322e0616c2835b'
lua_file_name = 'ItemUseHpHeal.lua'
sha = self._load_lua_script(lua_file_name, sha)
return msgpack.unpackb(self._redis.evalsha(sha, 1, key, team_id, user_id, target_id, heal_effect, use_item_id, item_category_id, get_serial_date()))
elif item_category == ActionType.use_item_dead_heal:
key = '{0}:'.format(war_id)
sha = 'bbbbafd3b3977c7441783f258c322e0616c2835b'
lua_file_name = 'ItemUseAed.lua'
sha = self._load_lua_script(lua_file_name, sha)
return msgpack.unpackb(self._redis.evalsha(sha, 1, key, team_id, user_id, target_id, use_item_id, item_category_id, get_serial_date()))
elif item_category == ActionType.use_item_skill_heal:
pass
def get_datetime_from_serial():
now_time = get_serial_date()
base = datetime.strptime('1970-01-01 00:00:00',
'%Y-%m-%d %H:%M:%S')
return (base +
timedelta(0, now_time)).strftime('%Y-%m-%d %H:%M:%S')
