def tick(self, global_time=None):
# if self.player1.victorious is not None or self.player2.victorious is not None:
# return
if self.tick_count < self.turn_time:
if self.global_time != global_time:
self.tick_count += 1
self.player1.tick += 1
self.player2.tick += 1
message = {"t": "Tick", "v": {"t": self.tick_count}}
self.send(
"{}{}".format(normal_length(len(str(message))), message),
self.player1)
self.send(
"{}{}".format(normal_length(len(str(message))), message),
self.player2)
self.global_time = global_time
else:
self.tick_count = 0
self.player1.tick = 0
self.player2.tick = 0
self.player1.ready = False
self.player2.ready = False
self.stat = 'turn_change'
def start(self):
self.player1.party, self.player2.party = self.party_creator()
message = {"t": "BattleData", "v": self.player1.party}
message = json.dumps(message)
self.send("{}{}".format(normal_length(len(str(message))), message),
self.player1)
if not self.player2.is_bot:
message = {"t": "BattleData", "v": self.player2.party}
message = json.dumps(message)
self.send("{}{}".format(normal_length(len(str(message))), message),
self.player2)
battle_start_data = {
"player_1_username": self.player1.player_client.user.username,
"player_1_bot": self.player1.is_bot,
"player_2_username": self.player2.player_client.user.username,
"player_2_bot": self.player2.is_bot,
"params": {
"player_1": self.player1.party,
"player_2": self.player2.party
},
"battle_id": self.id
}
create_battle_log.delay(**battle_start_data)
result = {
"battle_id": self.id,
"state": "start",
"params": {
"player_1": self.player1.party,
"player_2": self.player2.party
}
}
if settings.ACTIVE_LOG:
battle_log.delay(**result)
def clientConnectionLost(self, client):
if client in clients:
clients.remove(client)
if not client.battle.battle_end:
if client.user.username == client.battle.player1.player_client.user.username:
winner = client.battle.player2
loser = client.battle.player1
else:
winner = client.battle.player1
loser = client.battle.player2
winner.victorious = True
loser.victorious = False
if not winner.is_bot:
winner_profile = ProfileUpdateViewer(winner)
winner_data = winner_profile.generate()
chest = CtmChestGenerate(winner.player_client.user)
chest = chest.generate_chest()
winner_message = {
"t": "BattleResult",
"v": {
"victorious": str(winner.victorious),
"reward": {
"coin": winner_data['coin'],
"trophy": winner_data['trophy']
},
"cooldown_data": [],
"connection_lost": "True"
}
}
if chest is not None:
winner_message['v']['reward']['chest_info'] = chest
winner_message = str(winner_message).replace("u'", '"')
client.battle.send("{}{}".format(normal_length(len(str(winner_message))), winner_message), winner)
winner.player_client.transport.loseConnection()
loser_profile = ProfileUpdateViewer(loser)
loser_data = loser_profile.generate()
def check_end_battle(self):
if self.player1.party['party'][0]['troop'][0]['health'] <= 0 \
or self.player1.party['party'][0]['troop'][-1]['health'] <= 0:
winner = self.player2
loser = self.player1
elif self.player1.party['party'][1]['troop'][0]['health'] <= 0 \
or self.player1.party['party'][1]['troop'][-1]['health'] <= 0:
winner = self.player1
loser = self.player2
else:
return False
winner.victorious = True
loser.victorious = False
self.battle_end = True
if winner.player_client in clients:
clients.remove(winner.player_client)
if loser.player_client in clients:
clients.remove(loser.player_client)
if not winner.is_bot:
profile_log(winner, 'win')
winner_profile = ProfileUpdateViewer(winner)
winner_data = winner_profile.generate()
troop_record(winner.troops)
chest = CtmChestGenerate(winner.player_client.user)
print "winner playoff:", winner.is_playoff
if winner.is_playoff:
playoff_log(winner.player_client.user, 'win')
winner_league_type = winner_profile.join_to_league()
cool_down_troop_lst = cool_down_troop(winner)
winner_message = {
"t": "BattleResult",
"v": {
"victorious": str(winner.victorious),
"reward": {
"coin":
winner_data['coin'],
"trophy":
0 if winner_league_type == 'promoted' else
winner_data['trophy']
},
"cooldown_data": cool_down_troop_lst,
"connection_lost": "False"
}
}
chest = chest.generate_chest()
if chest is not None:
winner_message['v']['reward']['chest_info'] = chest
winner_message = str(winner_message).replace("u'", '"')
self.send(
"{}{}".format(normal_length(len(str(winner_message))),
winner_message), winner)
if not loser.is_bot:
profile_log(loser, 'lose')
loser_profile = ProfileUpdateViewer(loser)
loser_data = loser_profile.generate()
troop_record(loser.troops, type_fight='loser')
print "loser playoff:", loser.is_playoff
if loser.is_playoff:
playoff_log(loser.player_client.user, 'lose')
loser_profile.join_to_league()
loser_message = {
"t": "BattleResult",
"v": {
"victorious": str(loser.victorious),
"reward": {
"coin": 0,
"trophy": loser_data['trophy'],
},
"cooldown_data": cool_down_troop(loser)
}
}
loser_message = str(loser_message).replace("u'", '"')
self.send(
"{}{}".format(normal_length(len(str(loser_message))),
loser_message), loser)
if settings.ACTIVE_LOG:
end_battle_log.delay(self.id)
if not winner.is_bot:
winner.player_client.transport.loseConnection()
if not loser.is_bot:
loser.player_client.transport.loseConnection()
def action(self, player, spell, target):
spell_key, spell_value = self.find(spell,
self.active_turn["eligible_spells"],
'index')
self.tick_count = 0
self.player1.tick = 0
self.player2.tick = 0
self.player1.ready = False
self.player2.ready = False
print "player:", player, "active_turn:", self.active_turn[
'player'].player_client
if (player == self.active_turn['player'].player_client
and spell_key) or self.player2.is_bot:
troops = self.active_turn['enemy'].party['party'][0]['troop'] + \
self.active_turn['enemy'].party['party'][1]['troop']
troop_key, troop_value = self.find(target, troops, 'id')
if troop_key:
if player.battle.player1.player_client.user.username == player.user.username:
selected_player = player.battle.player1
enemy = player.battle.player2
else:
selected_player = player.battle.player2
enemy = player.battle.player1
owner_troops = self.active_turn['player'].party['party'][0][
'troop']
owner_troop_key, owner_value = self.find(
self.active_turn['turn_id'], owner_troops, 'id')
selected_spell = Factory().create(owner_value, spell_value,
troop_value, selected_player,
enemy)
message = selected_spell.run()
self.send(
"{}{}".format(normal_length(len(str(message))), message),
self.player1)
self.send(
"{}{}".format(normal_length(len(str(message))), message),
self.player2)
else:
message = {
"t": "Error",
"v": {
'error_code': 600,
"msg": "data invalid!!!"
}
}
message = "{}{}".format(normal_length(len(str(message))),
message)
self.player1.player_client.transport.write(message)
if not self.player2.is_bot:
self.player2.player_client.transport.write(message)
else:
message = {
"t": "Error",
"v": {
'error_code': 600,
"msg": "data invalid!!!"
}
}
message = "{}{}".format(normal_length(len(str(message))), message)
self.player1.player_client.transport.write(message)
if not self.player2.is_bot:
self.player2.player_client.transport.write(message)
result = {"battle_id": self.id, "state": "action", "params": message}
if settings.ACTIVE_LOG:
battle_log.delay(**result)
self.check_end_battle()
self.stat = 'turn_change'
def turn_change(self):
if self.player1.victorious is not None or self.player2.victorious is not None:
return
player, enemy, result = self.valid_turn()
lst_status_update_data = []
lst_index_delete = []
lst_spells = player.player_client.battle.live_spells
for i in range(0, len(lst_spells)):
troop = self.find_troop(lst_spells[i])
if lst_spells[i]['player'] != player.player_client.user.username \
and lst_spells[i]['turn_type'] == 'enemy_turn':
if lst_spells[i]['turn_count'] > 0:
lst_spells[i]['turn_count'] = int(
lst_spells[i]['turn_count']) - 1
else:
remove_flag = BattleFlags.Taunt.value
lst_status_update_data.append(
self.live_spell_stat(
spell=lst_spells[i],
stat_change_type=SpellSingleStatChangeType.
curFlagValChange,
remove_flag=remove_flag))
lst_index_delete.append(i)
else:
if lst_spells[i]['action'] in ['burn', 'poison']:
if troop['shield'] > 0:
troop['shield'] -= 0 if lst_spells[i][
'damage'] is None else int(lst_spells[i]['damage'])
lst_status_update_data.append(
self.live_spell_stat(
spell=lst_spells[i],
damage=0 if lst_spells[i]['damage'] is None
else int(lst_spells[i]['damage']),
stat_change_type=SpellSingleStatChangeType.
curShieldValChange))
else:
if troop['health'] > 0:
troop['health'] -= 0 if lst_spells[i][
'damage'] is None else lst_spells[i]['damage']
if troop['health'] < 0:
troop['health'] = 0
if i not in lst_index_delete:
lst_index_delete.append(i)
lst_status_update_data.append(
self.live_spell_stat(
spell=lst_spells[i],
damage=lst_spells[i]['damage'],
stat_change_type=SpellSingleStatChangeType.
curHpValChange))
lst_spells[i]['turn_count'] = int(
lst_spells[i]['turn_count']) - 1
if lst_spells[i]['turn_count'] == 0:
if lst_spells[i][
'action'] == 'burn' and BattleFlags.Burn.value in troop[
'flag']:
lst_spells[i]['troop'][0]['flag'].remove(
BattleFlags.Burn.value)
if BattleFlags.Burn.value in troop['flag']:
troop['flag'].remove(BattleFlags.Burn.value)
if lst_spells[i][
'action'] == 'poison' and BattleFlags.Poison.value in troop[
'flag']:
lst_spells[i]['troop'][0]['flag'].remove(
BattleFlags.Poison.value)
if BattleFlags.Poison.value in troop['flag']:
troop['flag'].remove(BattleFlags.Poison.value)
if lst_spells[i][
'action'] == 'confuse' and BattleFlags.Confuse.value in troop[
'flag']:
lst_spells[i]['troop'][0]['flag'].remove(
BattleFlags.Confuse.value)
if lst_spells[i]['action'] == 'damage_reduction' and \
BattleFlags.DamageReduction.value in troop['flag']:
lst_spells[i]['troop'][0]['flag'].remove(
BattleFlags.DamageReduction.value)
lst_status_update_data.append(
self.live_spell_stat(
spell=lst_spells[i],
stat_change_type=SpellSingleStatChangeType.
curFlagValChange))
if i not in lst_index_delete:
lst_index_delete.append(i)
result, message = self.chakra_check()
if result:
self.lst_pre_fight.append(message)
else:
self.stat = 'tick'
for i in range(0, len(lst_spells)):
if i in lst_index_delete:
try:
lst_spells.pop(i)
except Exception as e:
print "error", e
player, enemy, result = self.valid_turn()
data = {
"turn_id":
self.turns_sequence[self.turn_pointer],
"eligible_spells": [
item['index'] for item in result['spell']
if item['need_ap'] <= player.action_point
],
"eligible_secrets": [],
"cool_down_spells": [],
"status_update_data":
lst_status_update_data,
"player":
str(player.player_client.user.username).encode('utf-8'),
"enemy":
str(enemy.player_client.user.username).encode('utf-8')
}
self.active_turn = data.copy()
self.active_turn['player'] = player
self.active_turn['enemy'] = enemy
self.active_turn['eligible_spells'] = result['spell']
result = {"t": "TurnData", "v": data}
if not player.is_bot:
data['ap'] = [player.action_point, enemy.action_point]
self.send("{}{}".format(normal_length(len(str(result))), result),
player)
if not enemy.is_bot:
data['ap'] = [enemy.action_point, player.action_point]
self.send("{}{}".format(normal_length(len(str(result))), result),
enemy)
print "turn_change___data:{},", data
self.turn_pointer += 1
self.turn_count += 1
result = {"battle_id": self.id, "state": "turn_change", "params": data}
if settings.ACTIVE_LOG:
battle_log.delay(**result)
self.check_end_battle()
if len(self.lst_pre_fight) > 0:
self.stat = "tick"
action_list = []
for action in self.lst_pre_fight:
action_list.append(action)
self.lst_pre_fight = []
message = {"t": "FightAction", "v": {"f_acts": action_list}}
self.send("{}{}".format(normal_length(len(str(message))), message),
player)
self.send("{}{}".format(normal_length(len(str(message))), message),
enemy)
def dataReceived(self, data):
try:
clean_data = json.loads(data)
print 'clean data:{}'.format(clean_data)
if not self.user:
user = get_user(clean_data['username'])
if user in [client.user for client in clients]:
message = {
"t": "Error",
"v": {'error_code': 501, 'msg': 'user {} already exists with id:{}'.format(user.username, user.id)}
}
self.transport.write('{}{}'.format(normal_length(len(str(message))), str(message).replace("'", '"')))
return
if user:
self.user = user
self.troops = clean_data['troops_id']
else:
message = {
"t": "Error",
"v": {'error_code': 500, 'msg': 'user login failed'}
}
self.transport.write('{}{}'.format(normal_length(len(str(message))), str(message).replace("'", '"')))
if not self.battle:
battle_finder(self)
return
if not self.battle.player1.ready or not self.battle.player2.ready:
if clean_data['user_ready']:
if self.battle.player1.player_client == self:
self.battle.player1.ready = True
if self.battle.player2.is_bot:
self.battle.player2.ready = True
if self.battle.player2.player_client == self:
self.battle.player2.ready = True
if self.battle.player1.is_bot:
self.battle.player1.ready = True
self.battle.user_ready()
return
if clean_data['flag'] == "action":
self.battle.action(self, clean_data['spell_index'], clean_data['target_id'])
return
except ValueError as e:
message = {
"t": "Error",
"v": {'error_code': 400, 'msg': 'data invalid!!!{}'.format(e)}
}
self.transport.write('{}{}'.format(normal_length(len(str(message))), str(message).replace("'", '"')))
print 'value error-{}'.format(e.message)
except KeyError as e:
message = {
"t": "Error",
"v": {'error_code': 401, 'msg': 'data invalid!!!{}'.format(e)}
}
self.transport.write('{}{}'.format(normal_length(len(str(message))), str(message).replace("'", "'")))
print 'KeyError-{}'.format(e.message)
except Exception as e:
message = {
"t": "Error",
"v": {'error_code': 402, 'msg': 'data invalid!!!{}'.format(e)}
}
self.transport.write('{}{}'.format(normal_length(len(str(message))), str(message).replace("'", '"')))
print 'Exception-{}'.format(e.message)
def dataReceived(self, data):
# try:
clean_data = json.loads(data)
log.msg(clean_data)
if not self.user:
user = get_user(clean_data['username'])
self.is_playoff = clean_data['is_playoff']
if user in [client.user for client in clients]:
message = {
"t": "Error",
"v": {
'error_code':
501,
'msg':
'user {} already exists with id:{}'.format(
user.username, user.id)
}
}
self.transport.write('{}{}'.format(
normal_length(len(str(message))),
str(message).replace("'", '"')))
return
if user:
self.user = user
self.profile = get_profile(user.id)
self.troops = clean_data['troops_id']
else:
message = {
"t": "Error",
"v": {
'error_code': 500,
'msg': 'user login failed'
}
}
self.transport.write('{}{}'.format(
normal_length(len(str(message))),
str(message).replace("'", '"')))
if not self.battle:
battle_finder(self)
return
if not self.battle.player1.ready or not self.battle.player2.ready:
if clean_data['user_ready']:
if self.battle.player1.player_client == self:
self.battle.player1.ready = True
if self.battle.player2.is_bot:
self.battle.player2.ready = True
if self.battle.player2.player_client == self:
self.battle.player2.ready = True
if self.battle.player1.is_bot:
self.battle.player1.ready = True
self.battle.user_ready()
return
if clean_data['flag'] == "action":
self.battle.action(self, clean_data['spell_index'],
clean_data['target_id'])
return
def clientConnectionLost(self, client):
if client in clients:
clients.remove(client)
if client.battle and not client.battle.battle_end:
if client.user.username == client.battle.player1.player_client.user.username:
winner = client.battle.player2
loser = client.battle.player1
else:
winner = client.battle.player1
loser = client.battle.player2
winner.victorious = True
loser.victorious = False
if not winner.is_bot:
winner_profile = ProfileUpdateViewer(winner)
winner_data = winner_profile.generate()
chest = CtmChestGenerate(winner.player_client.user)
chest = chest.generate_chest()
troop_record(winner.troops)
profile_log(winner, 'win')
if winner.is_playoff:
playoff_log(winner.player_client.user, 'win')
winner_profile.join_to_league()
winner_message = {
"t": "BattleResult",
"v": {
"victorious": str(winner.victorious),
"reward": {
"coin": winner_data['coin'],
"trophy": winner_data['trophy']
},
"cooldown_data": cool_down_troop(winner),
"connection_lost": "True"
}
}
if chest is not None:
winner_message['v']['reward']['chest_info'] = chest
winner_message = str(winner_message).replace("u'", '"')
client.battle.send(
"{}{}".format(normal_length(len(str(winner_message))),
winner_message), winner)
winner.player_client.transport.loseConnection()
# loser_profile = ProfileUpdateViewer(loser)
# loser_data = loser_profile.generate()
if not loser.is_bot:
profile_log(loser)
loser_cooldown = cool_down_troop(loser)
troop_record(loser.troops, type_fight='loser')
if loser.is_playoff:
playoff_log(loser.player_client.user, 'lose')
loser_profile = ProfileUpdateViewer(loser)
loser_data = loser_profile.generate()
loser_profile.join_to_league()
if settings.ACTIVE_LOG:
end_battle_log.delay(client.battle.id)