def parse_ship_descriptor(ship: Ship, line: dict, lines: list, event: tuple):
"""
Parse an event_descriptor of the SHIP type. Supports ability,
component and crew type operations.
:param ship: Ship instance for the spawn described by lines
:param line: Trigger line dictionary
:param lines: List of lines in this spawn
:param event: Event descriptor tuple (PatternParser docstring)
:return: The result of results this SHIP event descriptor
"""
if event[0] != Patterns.SHIP:
raise InvalidDescriptor(event)
event_type, args = event[1], event[2:] # "ability", "component", "crew"
# Parse Component selected
if event_type == "component":
# Component must be selected on the Ship for this spawn
component, = args
return PatternParser.get_component_in_ship(lines, ship, component)
# Parse Crew selected
elif event_type == "crew":
crew, = args
return PatternParser.get_crew_in_ship(ship, crew)
# Parse Ability Available
elif event_type == "ability":
return PatternParser.parse_ability_availability(line, lines, event, ship)
# Parse ship type selected
elif event_type == "type":
# TODO: Optimize usage
player = Parser.get_player_id_list(lines)
abs_dict = Parser.get_abilities_dict(lines, player)
ship_name = ship.name if ship is None else Parser.get_ship_for_dict(abs_dict)
ship_type, = args
return get_ship_category(ship_name) == ship_type
raise InvalidDescriptor(event)
def get_component_in_ship(lines: list, ship: Ship, component: (str, Component)):
"""Return whether a component is found within a Ship instance"""
if isinstance(component, Component):
name, category = component.name, component.category
else: # str
name = component
category = PatternParser.get_component_category(component)
player = Parser.get_player_id_list(lines)
abilities = Parser.get_abilities_dict(lines, player)
if name in abilities:
return True
if ship is None:
return False # Ship option not available at results time
if category not in ship:
return False # Configured improperly at results time
categories = (category,)
if "Weapon" in category: # Extend to double primaries/secondaries
categories += (category[0] + "2",)
# Loop over categories
result = False
for category in categories:
if category not in ship: # Double primaries/secondaries
continue
component = ship[category]
if not isinstance(component, Component): # Improper config
print("[PatternParser] Improperly configured Ship instance:", ship, component)
continue
if component.name == name:
result = True
break
continue
return result
def _select_date(self, date: datetime):
"""Callback for Calendar widget selection command"""
self.clear_data_widgets()
self._tree.delete(*self._tree.get_children(""))
if date not in self._dates:
return
self._files: List[str] = self._dates[date]
for f, file in enumerate(sorted(self._files)):
name = Parser.get_player_name_raw(file)
cube, matches, spawns = Parser.split_combatlog_file(file)
for m, match in enumerate(sorted(matches[::2])):
match = datetime.strftime(match, "%H:%M, {}".format(name))
match_iid = "{},{}".format(f, m)
self._tree.insert("", tk.END, text=match, iid=match_iid)
for s, spawn in enumerate(sorted(spawns[m])):
spawn = datetime.strftime(spawn, "%H:%M:%S")
player_list: List[str] = Parser.get_player_id_list(cube[m][s])
abs_dict: Dict[str: int] = Parser.get_abilities_dict(cube[m][s], player_list)
ships: List[str] = Parser.get_ship_for_dict(abs_dict)
ship = self.format_ships_list(ships)
spawn = "{}{}".format(spawn, ship)
spawn_iid = "{},{},{}".format(f, m, s)
self._tree.insert(match_iid, tk.END, text=spawn, iid=spawn_iid)
def test_get_abilities_dict(self):
lines = Parser.read_file(self.FILE)
player = Parser.get_player_id_list(lines)
abilities = Parser.get_abilities_dict(lines, player)
self.assertIsInstance(abilities, dict)
