def _send_position(self):
"""
Go through all events and check intersections
"""
events = self.EVENTS['im_in_area']
for event in events[:]:
receiver = self.fighters[event['receiver_id']]
distance = euclidean_distance(receiver.coordinates,
event["data"]["coordinates"])
if distance < event["data"]["radius"]:
receiver.send_event(lookup_key=event['lookup_key'],
data={
ATTRIBUTE.ID: receiver.id,
"distance": distance
})
events.remove(event)
events = self.EVENTS['enemy_in_my_firing_range']
for event in events[:]:
receiver = self.fighters[event['receiver_id']]
for event_item in self.battle_fighters():
if receiver == event_item:
continue
if event_item.player == receiver.player:
continue
distance = euclidean_distance(receiver.coordinates,
event_item.coordinates)
if distance - event_item.size / 2 > receiver.firing_range:
continue
receiver.send_event(lookup_key=event['lookup_key'],
data={'id': event_item.id})
events.remove(event)
break
events = self.EVENTS['any_item_in_area']
for event in events[:]:
receiver = self.fighters[event['receiver_id']]
for event_item in self.battle_fighters():
distance = euclidean_distance(event['data']['coordinates'],
event_item.coordinates)
if distance > event['data']['radius']:
continue
receiver.send_event(lookup_key=event['lookup_key'],
data={'id': event_item.id})
events.remove(event)
break
def check_function(event, event_item, receiver):
if (receiver.id != event_item.id and
not event_item.is_obstacle and
event_item.player != receiver.player):
distance = euclidean_distance(receiver.coordinates, event_item.coordinates)
return distance - event_item.size / 2 <= receiver.firing_range
return False
def setup(self):
fight_handler = self._fight_handler
fighters = fight_handler.fighters
self.add_checker(
'time', lambda event, receiver: fight_handler.current_game_time >=
event['data']['time'],
lambda event, receiver, res: {'time': event['data']['time']})
self.add_checker(
'idle', lambda event, receiver:
(event['data']['id'] in fighters and fighters[event['data']['id']].
_state.get('action') == 'idle'),
lambda event, receiver, res: {'id': event['data']['id']})
self.add_checker(
'enemy_in_my_firing_range',
self.gen_fighters_checker(lambda event_item, event, receiver: (
euclidean_distance(receiver.coordinates, event_item.coordinates
) - event_item.size / 2 <= receiver.
firing_range) and receiver.player_id != event_item.player_id),
lambda event, receiver, res: {'id': res.id})
self.add_checker(
'death', lambda event, receiver: fighters.get(event['data'][
'id']) and fighters.get(event['data']['id']).is_dead,
lambda event, receiver, res: {'id': event['data']['id']})
self.add_checker(
'unit_landed',
self.gen_fighters_checker(
lambda event_item, event, receiver: event_item.fflag('landed')
and event['data']['craft_id'] == event_item.craft_id),
lambda event, receiver, res: res.info)
def _send_position(self):
"""
Go through all events and check intersections
"""
events = self.EVENTS['im_in_area']
for event in events[:]:
receiver = self.fighters[event['receiver_id']]
distance = euclidean_distance(receiver.coordinates, event["data"]["coordinates"])
if distance < event["data"]["radius"]:
receiver.send_event(lookup_key=event['lookup_key'],
data={ATTRIBUTE.ID: receiver.id, "distance": distance})
events.remove(event)
events = self.EVENTS['enemy_in_my_firing_range']
for event in events[:]:
receiver = self.fighters[event['receiver_id']]
for event_item in self.battle_fighters():
if receiver == event_item:
continue
if event_item.player == receiver.player:
continue
distance = euclidean_distance(receiver.coordinates, event_item.coordinates)
if distance - event_item.size / 2 > receiver.firing_range:
continue
receiver.send_event(lookup_key=event['lookup_key'],
data={'id': event_item.id})
events.remove(event)
break
events = self.EVENTS['any_item_in_area']
for event in events[:]:
receiver = self.fighters[event['receiver_id']]
for event_item in self.battle_fighters():
distance = euclidean_distance(event['data']['coordinates'], event_item.coordinates)
if distance > event['data']['radius']:
continue
receiver.send_event(lookup_key=event['lookup_key'],
data={'id': event_item.id})
events.remove(event)
break
def get_enemy_items_in_my_firing_range(self, item_id):
seeker = self.fighters[item_id]
result = []
for other in self.fighters.values():
if other.player == seeker.player or other.is_dead or other.is_obstacle:
continue
distance = euclidean_distance(other.coordinates, seeker.coordinates)
if distance - other.size / 2 <= seeker.firing_range:
result.append(self.get_item_info(other.id))
return result
def validate_attack(self, action, data):
enemy = self._fight_handler.fighters.get(data['id'])
if enemy.is_dead:
raise ActionValidateError("The enemy is dead")
if enemy.player['id'] == self._item.player['id']:
raise ActionValidateError("Can not attack own item")
distance_to_enemy = euclidean_distance(enemy.coordinates, self._item.coordinates)
item_firing_range = self._item.firing_range
if distance_to_enemy - enemy.size / 2 > item_firing_range:
raise ActionValidateError("Can not attack item, it's big distance")
def validate_attack(self, action, data):
enemy = self._fight_handler.fighters.get(data['id'])
if enemy.is_dead:
raise ActionValidateError("The enemy is dead")
if enemy.player['id'] == self._item.player['id']:
raise ActionValidateError("Can not attack own item")
distance_to_enemy = euclidean_distance(enemy.coordinates, self._item.coordinates)
item_firing_range = self._item.firing_range
if distance_to_enemy - enemy.size / 2 > item_firing_range:
raise ActionValidateError("Can not attack item, it's big distance")
def explode(self):
self.is_dead = True
for item in self.item._fight_handler.fighters.values():
if item.role != ROLE.UNIT or item == self.item:
continue
distance = euclidean_distance(item.coordinates, self.cur_coor)
if distance > self.explode_radius:
continue
damage = (self.explode_radius - distance) * self.item.damage_per_shot
item.get_shoted(damage)
def explode(self):
self.is_dead = True
for item in self.item._fight_handler.fighters.values():
if item.player_id == self.item.player_id or not item.coordinates:
continue
distance = euclidean_distance(item.coordinates, self.cur_coor)
if distance > self.explode_radius:
continue
damage = (self.explode_radius -
distance) * self.damage_per_shot / self.explode_radius
item.get_shoted(damage)
def do_frame_action(self):
distance = euclidean_distance(self.cur_coor, self.target_coor)
if distance <= self.speed:
self.cur_coor = self.target_coor
self.explode()
return
def calc_single_coor(cur, target):
return (target - cur) * self.speed / distance + cur
self.cur_coor = [
calc_single_coor(self.cur_coor[0], self.target_coor[0]),
calc_single_coor(self.cur_coor[1], self.target_coor[1])
]
def do_frame_action(self):
distance = euclidean_distance(self.cur_coor, self.target_coor)
if distance <= self.speed:
self.cur_coor = self.target_coor
self.explode()
return
def calc_single_coor(cur, target):
return (target - cur) * self.speed / distance + cur
self.cur_coor = [
calc_single_coor(self.cur_coor[0], self.target_coor[0]),
calc_single_coor(self.cur_coor[1], self.target_coor[1])
]
def _shot(self, enemy):
charged = self._get_charged(enemy.coordinates, enemy.id)
if charged:
return charged
attacker = self._item
if (euclidean_distance(enemy.coordinates, attacker.coordinates) -
enemy.size / 2) <= attacker.firing_range:
return self._actual_shot(enemy)
if enemy.is_dead:
return self._idle()
return self._idle()
def _shot(self, enemy):
charged = self._get_charged(enemy.coordinates, enemy.id)
if charged:
return charged
attacker = self._item
if (euclidean_distance(enemy.coordinates, attacker.coordinates) -
enemy.size / 2) <= attacker.firing_range:
return self._actual_shot(enemy)
if enemy.is_dead:
return self._idle()
return self._idle()
def get_nearest_enemy(self, item_id):
min_length = 1000
nearest_enemy = None
fighter = self.fighters[item_id]
for item in self.fighters.values():
if item.player == fighter.player or item.is_dead or item.is_obstacle:
continue
length = euclidean_distance(item.coordinates, fighter.coordinates)
if length < min_length:
min_length = length
nearest_enemy = item
return self.get_item_info(nearest_enemy.id)
def do_frame_action(self):
for item in self.item._fight_handler.fighters.values():
if not item.coordinates or (
item.player_id == self.item.player_id
and not self.is_support
) or (item.player_id != self.item.player_id and self.is_support):
continue
distance = euclidean_distance(item.coordinates, self.coor)
if distance > self.radius:
continue
self.act(item, self.power)
self.timer -= self.item._fight_handler.GAME_FRAME_TIME
if self.timer <= 0:
self.is_dead = True
def explode():
self.is_dead = True
for item in self._fight_handler.fighters.values():
if item.is_dead:
continue
if item.player_id == self.item.player_id:
continue
if item.role != ROLE.UNIT:
continue
distance = euclidean_distance(item.coordinates, self.coordinates)
if distance > self.firing_range:
continue
damage = (self.firing_range -
distance) * self.damage_per_shot / self.firing_range
item.get_shoted(damage)
def check_function(event, event_item, receiver):
distance = euclidean_distance(event['data']['coordinates'], event_item.coordinates)
return distance <= event['data']['radius']
def check_function(event, event_item, receiver):
if event["data"]["item_id"] == event_item.id:
distance = euclidean_distance(receiver.coordinates, event_item.coordinates)
return distance - event_item.size / 2 > receiver.firing_range
return False
def data_function(event, event_item, receiver):
distance = euclidean_distance(receiver.coordinates, event["data"]["coordinates"])
return {ATTRIBUTE.ID: event_item.id, "distance": distance}
def check_function(event, event_item, receiver):
if receiver.id == event_item.id:
distance = euclidean_distance(receiver.coordinates, event["data"]["coordinates"])
return distance < event["data"]["radius"]
return False
