Coverage for F:\DEV\EMIZ\emiz\mission.py : 36%

Hot-keys on this page
r m x p toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
# coding=utf-8
exc=ValueError, logger=LOGGER)
super().__init__()
if not isinstance(mission_dict, dict): raise TypeError('mission_dict should be an dict, got: {}'.format(type(mission_dict)))
if not isinstance(l10n, dict): raise TypeError('l10n should be an dict, got: {}'.format(type(l10n)))
self.d = mission_dict self.l10n = l10n
self.weather = None self.blue_coa = None self.red_coa = None self.ground_control = None
self._countries_by_name = {} self._countries_by_id = {}
valid_str.validate(country_name, 'get_country_by_name', exc=ValueError) if country_name not in self._countries_by_name.keys(): for country in self.countries: assert isinstance(country, Country) if country.country_name == country_name: self._countries_by_name[country_name] = country return country raise ValueError(country_name) else: return self._countries_by_name[country_name]
valid_positive_int.validate(country_id, 'get_country_by_id') if country_id not in self._countries_by_id.keys(): for country in self.countries: assert isinstance(country, Country) if country.country_id == country_id: self._countries_by_id[country_id] = country return country raise ValueError(country_id) else: return self._countries_by_id[country_id]
Mission.validator_group_category.validate(category, 'get_groups_from_category') for group in self.groups: if group.group_category == category: yield group
Mission.validator_group_category.validate(category, 'get_units_from_category') for unit in self.units: if unit.group_category == category: yield unit
valid_positive_int.validate(group_id, 'get_group_by_id', exc=ValueError) for group in self.groups: assert isinstance(group, Group) if group.group_id == group_id: return group return None
for group in self.groups: assert isinstance(group, Group) if group.group_is_client_group: yield group
valid_str.validate(group_name, 'get_group_by_name') for group in self.groups: assert isinstance(group, Group) if group.group_name == group_name: return group return None
valid_str.validate(unit_name, 'get_unit_by_name') for unit in self.units: assert isinstance(unit, BaseUnit) if unit.unit_name == unit_name: return unit return None
valid_positive_int.validate(unit_id, 'get_unit_by_id') for unit in self.units: assert isinstance(unit, BaseUnit) if unit.unit_id == unit_id: return unit return None
def units(self): for group in self.groups: for unit in group.units: assert isinstance(unit, BaseUnit) yield unit
def groups(self): for country in self.countries: for group in country.groups: assert isinstance(group, Group) yield group
def next_group_id(self): ids = set() for group in chain(self.blue_coa.groups, self.red_coa.groups): assert isinstance(group, Group) id_ = group.group_id if id_ in ids: raise IndexError(group.group_name) ids.add(id_) return max(ids) + 1
def next_unit_id(self): ids = set() for unit in chain(self.blue_coa.units, self.red_coa.units): assert isinstance(unit, BaseUnit) id_ = unit.unit_id if id_ in ids: raise IndexError(unit.unit_name) ids.add(id_) return max(ids) + 1
def coalitions(self): for coalition in [self.blue_coa, self.red_coa]: assert isinstance(coalition, Coalition) yield coalition
def countries(self): for coalition in self.coalitions: for country in coalition.countries: assert isinstance(country, Country) yield country
def mission_start_time(self): return self.d['start_time']
def mission_start_time(self, value): Mission.validator_start_time.validate(value, 'start_time') self.d['start_time'] = value
def mission_start_time_as_date(self): return strftime('%d/%m/%Y %H:%M:%S', gmtime(EPOCH_DELTA + self.mission_start_time))
def mission_start_time_as_date(self, value): Mission.validator_start_date.validate(value, 'start_time_as_date') self.mission_start_time = timegm(strptime(value, '%d/%m/%Y %H:%M:%S')) - EPOCH_DELTA
def _sortie_name_key(self): return self.d['sortie']
def sortie_name(self): return self.l10n[self._sortie_name_key]
def sortie_name(self, value): valid_str.validate(value, 'sortie name') self.l10n[self._sortie_name_key] = value
_type=int, _min=0, exc=ValueError, logger=LOGGER ) _type=str, _regex=r'^(?=\d)(?:(?:31(?!.(?:0?[2469]|11))|(?:30|29)(?!.0?2)|29' r'(?=.0?2.(?:(?:(?:1[6-9]|[2-9]\d)?(?:0[48]|[2468][048]|[13579][26])' r'|(?:(?:16|[2468][048]|[3579][26])00)))(?:\x20|$))|(?:2[0-8]|1\d|0?[1-9]))' r'([-./])(?:1[012]|0?[1-9])\1(?:1[6-9]|[2-9]\d)?\d\d(?:(?=\x20\d)\x20|$))?' r'(((0?[1-9]|1[012])(:[0-5]\d){0,2}(\x20[AP]M))|([01]\d|2[0-3])' r'(:[0-5]\d){1,2})?$', exc=ValueError, logger=LOGGER ) _type=int, _min=0, _max=359, exc=ValueError, logger=LOGGER ) _type=str, _in_list=['helicopter', 'ship', 'plane', 'vehicle'], exc=ValueError, logger=LOGGER)
super().__init__(mission_dict, l10n) self.weather = Weather(self.d, l10n) self.blue_coa = Coalition(self.d, l10n, 'blue') self.red_coa = Coalition(self.d, l10n, 'red') self.ground_control = GroundControl(self.d, l10n)
return 'Mission({})'.format(self.d)
for coa in [self.blue_coa, self.red_coa]: for farp in coa.farps: yield farp
# noinspection PyProtectedMember super().__init__(mission_dict, ln10) self.coa_color = coa_color self._countries = {}
return 'Coalition({}, {})'.format(self._section_coalition, self.coa_color)
if not isinstance(other, Coalition): raise ValueError('"other" must be an Coalition instance; got: {}'.format(type(other))) return self._section_coalition == other._section_coalition
def _section_coalition(self): return self.d['coalition'][self.coa_color]
def _section_bullseye(self): return self._section_coalition['bullseye']
def bullseye_x(self): return self._section_bullseye['x']
def bullseye_y(self): return self._section_bullseye['y']
def bullseye_position(self): return self.bullseye_x, self.bullseye_y
def _section_nav_points(self): return self._section_coalition['nav_points']
def coalition_name(self): return self._section_coalition['name']
def _section_country(self): return self._section_coalition['country']
for k in self._section_country: if k not in self._countries.keys(): country = Country(self.d, self.l10n, self.coa_color, k) self._countries[k] = country self._countries_by_id[country.country_id] = country self._countries_by_name[country.country_name] = country yield self._countries[k]
valid_str.validate(country_name, 'get_country_by_name', exc=ValueError) if country_name not in self._countries_by_name.keys(): for country in self.countries: assert isinstance(country, Country) if country.country_name == country_name: return country raise ValueError(country_name) else: return self._countries_by_name[country_name]
valid_positive_int.validate(country_id, 'get_country_by_id', exc=ValueError) if country_id not in self._countries_by_id.keys(): for country in self.countries: assert isinstance(country, Country) if country.country_id == country_id: return country raise ValueError(country_id) else: return self._countries_by_id[country_id]
for country in self.countries: assert isinstance(country, Country) for group in country.groups: assert isinstance(group, Group) yield group
for country in self.countries: assert isinstance(country, Country) for static in country.statics: assert isinstance(static, Static) yield static
for country in self.countries: assert isinstance(country, Country) for static in country.statics: assert isinstance(static, Static) if static.static_is_farp: yield static
Mission.validator_group_category.validate(category, 'get_groups_from_category') for group in self.groups: assert isinstance(group, Group) if group.group_category == category: yield group
for group in self.groups: assert isinstance(group, Group) for unit in group.units: yield unit
Mission.validator_group_category.validate(category, 'group category') for unit in self.units: assert isinstance(unit, BaseUnit) if unit.group_category == category: yield unit
valid_positive_int.validate(group_id, 'get_group_by_id') for group in self.groups: assert isinstance(group, Group) if group.group_id == group_id: return group
valid_str.validate(group_name, 'get_group_by_name') for group in self.groups: assert isinstance(group, Group) if group.group_name == group_name: return group
valid_str.validate(unit_name, 'get_unit_by_name') for unit in self.units: assert isinstance(unit, BaseUnit) if unit.unit_name == unit_name: return unit
valid_positive_int.validate(unit_id, 'get_unit_by_id') for unit in self.units: assert isinstance(unit, BaseUnit) if unit.unit_id == unit_id: return unit
super().__init__(mission_dict, l10n)
def _section_trig(self): return self.d['trig']
super().__init__(mission_dict, l10n)
def _section_result(self): return self.d['result']
super().__init__(mission_dict, l10n)
return 'GroundControl({})'.format(self._section_ground_control)
def _section_ground_control(self): return self.d['groundControl']
def _section_ground_control_roles(self): return self.d['groundControl']['roles']
def pilots_control_vehicles(self): return self._section_ground_control['isPilotControlVehicles']
def pilots_control_vehicles(self, value): valid_bool.validate(value, 'pilots_control_vehicles') self._section_ground_control['isPilotControlVehicles'] = value
def _section_artillery_commander(self): return self._section_ground_control_roles['artillery_commander']
def artillery_commander_red(self): return self._section_artillery_commander['red']
def artillery_commander_red(self, value): self.validator_commander.validate(value, 'artillery_commander_red') self._section_artillery_commander['red'] = value
def instructor_blue(self): return self._section_instructor['blue']
def instructor_blue(self, value): self.validator_commander.validate(value, 'instructor_blue') self._section_instructor['blue'] = value
def instructor_red(self): return self._section_instructor['red']
def instructor_red(self, value): self.validator_commander.validate(value, 'instructor_red') self._section_instructor['red'] = value
def _section_observer(self): return self._section_ground_control_roles['observer']
def observer_blue(self): return self._section_observer['blue']
def observer_blue(self, value): self.validator_commander.validate(value, 'observer_blue') self._section_observer['blue'] = value
def observer_red(self): return self._section_observer['red']
def observer_red(self, value): self.validator_commander.validate(value, 'observer_red') self._section_observer['red'] = value
def _section_forward_observer(self): return self._section_ground_control_roles['forward_observer']
def forward_observer_blue(self): return self._section_forward_observer['blue']
def forward_observer_blue(self, value): self.validator_commander.validate(value, 'forward_observer_blue') self._section_forward_observer['blue'] = value
def forward_observer_red(self): return self._section_forward_observer['red']
def forward_observer_red(self, value): self.validator_commander.validate(value, 'forward_observer_red') self._section_forward_observer['red'] = value
def artillery_commander_blue(self): return self._section_artillery_commander['blue']
def artillery_commander_blue(self, value): self.validator_commander.validate(value, 'artillery_commander_blue') self._section_artillery_commander['blue'] = value
def _section_instructor(self): return self._section_ground_control_roles['instructor']
# noinspection PyProtectedMember logger=LOGGER) logger=LOGGER) logger=LOGGER) logger=LOGGER) logger=LOGGER) 1: { 'name': 'summer', 'temp_validator': validator_temp_summer, }, 2: { 'name': 'winter', 'temp_validator': validator_temp_winter, }, 3: { 'name': 'spring', 'temp_validator': validator_temp_spring_or_fall, }, 4: { 'name': 'fall', 'temp_validator': validator_temp_spring_or_fall, }, 'summer': 1, 'winter': 2, 'spring': 3, 'fall': 4, } exc=ValueError, logger=LOGGER)
super().__init__(mission_dict, l10n)
return 'Weather({})'.format(self._section_weather)
if not isinstance(other, Weather): raise ValueError('"other" must be an Weather instance; got: {}'.format(type(other))) return self._section_weather == other._section_weather
self.validator_season_name.validate(season_name, 'get_season_code_from_name') return self.seasons_enum[season_name]
def _section_wind_at_ground_level(self): return self._section_wind['atGround']
def turbulence_at_ground_level(self): return self._section_weather['groundTurbulence']
def turbulence_at_ground_level(self, value): self.validator_turbulence.validate(value, 'turbulence_at_ground_level') self._section_weather['groundTurbulence'] = value
def wind_at_ground_level_speed(self): return self._section_wind_at_ground_level['speed']
def wind_at_ground_level_speed(self, value): self.validator_wind_speed.validate(value, 'wind_at_ground_level_speed') self._section_wind_at_ground_level['speed'] = value
def _section_fog(self): return self._section_weather['fog']
def fog_thickness(self): return self._section_fog['thickness']
def fog_thickness(self, value): self.validator_fog_thickness.validate(value, 'fog_thickness') self._section_fog['thickness'] = value
def fog_visibility(self): return self._section_fog['visibility']
def fog_visibility(self, value): self.validator_fog_visibility.validate(value, 'fog_visibility') self._section_fog['visibility'] = value
def fog_enabled(self): return self._section_weather['enable_fog']
def fog_enabled(self, value): valid_bool.validate(value, 'enable_fog') self._section_weather['enable_fog'] = value
def _section_visibility(self): return self._section_weather['visibility']
def visibility(self): return self._section_visibility['distance']
def visibility(self, value): self.validator_visibility.validate(value, 'visibility') self._section_visibility['distance'] = value
def precipitations(self): return self._section_clouds['iprecptns']
def precipitations(self, value): self.validator_precipitations.validate(value, 'precipitations') if value > 0 and self.cloud_density <= 4: raise ValueError('No rain or snow if cloud density is less than 5') if value in [2, 4] and self.cloud_density <= 8: raise ValueError('No thunderstorm or snowstorm if cloud density is less than 9') if value > 2 and self.temperature > 0: raise ValueError('No snow with temperature over 0; use rain or thunderstorm instead') if value in [1, 2] and self.temperature < 0: raise ValueError( 'No rain or thunderstorm if temperature is below 0; use snow or snowstorm instead') self._section_clouds['iprecptns'] = value
def wind_at8000_dir(self): return self._section_wind_at8000['speed']
def wind_at8000_dir(self, value): Mission.validator_heading.validate(value, 'wind_at8000_dir') self._section_wind_at8000['dir'] = value
def _section_weather(self): return self.d['weather']
def temperature(self): return self._section_season['temperature']
def temperature(self, value): self.validator_temperature.validate(value, 'temperature') self._section_season['temperature'] = value # if value > 0 and self.precipitations > 2: # self.precipitations -= 2 # if value < 0 < self.precipitations < 3: # PyKek # self.precipitations += 2
def _section_wind_at8000(self): return self._section_wind['at8000']
def wind_at_ground_level_dir(self): return self._section_wind_at_ground_level['dir']
def wind_at_ground_level_dir(self, value): Mission.validator_heading.validate(value, 'wind_at_ground_level_dir') self._section_wind_at_ground_level['dir'] = value
def _section_wind(self): return self._section_weather['wind']
def _section_wind_at2000(self): return self._section_wind['at2000']
def season_name(self): return self.seasons_enum[self.season_code]['name']
def qnh(self): return self._section_weather['qnh']
def qnh(self, value): self.validator_qnh.validate(value, 'qnh') self._section_weather['qnh'] = value
def wind_at2000_speed(self): return self._section_wind_at2000['speed']
def wind_at2000_speed(self, value): self.validator_wind_speed.validate(value, 'wind_at2000_speed') self._section_wind_at2000['speed'] = value
def wind_at2000_dir(self): return self._section_wind_at2000['dir']
def wind_at2000_dir(self, value): Mission.validator_heading.validate(value, 'wind_at2000_dir') self._section_wind_at2000['dir'] = value
def _section_season(self): return self._section_weather['season']
def atmosphere_type(self): return self._section_weather['atmosphere_type']
def atmosphere_type(self, value): self.validator_atmo_type.validate(value, 'atmosphere_type') self._section_weather['atmosphere_type'] = value
def season_code(self): return self._section_season['iseason']
def season_code(self, value): self.validator_season_code.validate(value, 'season') self._section_season['iseason'] = value if self.temperature < self.seasons_enum[value]['temp_validator'].min: self.temperature = self.seasons_enum[value]['temp_validator'].min if self.temperature > self.seasons_enum[value]['temp_validator'].max: self.temperature = self.seasons_enum[value]['temp_validator'].max
def _section_clouds(self): return self._section_weather['clouds']
def cloud_thickness(self): return self._section_clouds['thickness']
def cloud_thickness(self, value): self.validator_cloud_thickness.validate(value, 'cloud_thickness') self._section_clouds['thickness'] = value
def cloud_base(self): return self._section_clouds['base']
def cloud_base(self, value): self.validator_cloud_base.validate(value, 'cloud_base') self._section_clouds['base'] = value
def cloud_density(self): return self._section_clouds['density']
def cloud_density(self, value): self.validator_cloud_density.validate(value, 'cloud_density') self._section_clouds['density'] = value
def wind_at8000_speed(self): return self._section_wind_at8000['speed']
def wind_at8000_speed(self, value): self.validator_wind_speed.validate(value, 'wind_at8000_speed') self._section_wind_at8000['speed'] = value
# noinspection PyProtectedMember super().__init__(mission_dict, l10n, coa_color) self.__groups = { 'helicopter': {}, 'plane': {}, 'vehicle': {}, 'ship': {}, } self.country_index = country_index self.__static = {}
return 'Country({}, {}, {})'.format(self._section_country, self.coa_color, self.country_index)
if not isinstance(other, Country): raise ValueError('"other" must be an Country instance; got: {}'.format(type(other))) return self._section_country == other._section_country
def _section_this_country(self): return self._section_coalition['country'][self.country_index]
def country_id(self): return self._section_this_country['id']
def country_name(self): return self._section_this_country['name']
for group_category in Mission.valid_group_categories: if group_category in self._section_this_country.keys(): for group_index in self._section_this_country[group_category]['group']: if group_index not in self.__groups[group_category]: self.__groups[group_category][group_index] = Group(self.d, self.l10n, self.coa_color, self.country_index, group_category, group_index) yield self.__groups[group_category][group_index]
if 'static' in self._section_this_country.keys(): for static_index in self._section_this_country['static']['group']: if static_index not in self.__static: self.__static[static_index] = Static(self.d, self.l10n, self.coa_color, self.country_index, static_index) yield self.__static[static_index]
Mission.validator_group_category.validate(category, 'get_groups_from_category') for group in self.groups: assert isinstance(group, Group) if group.group_category == category: yield group
for group in self.groups: assert isinstance(group, Group) if group.group_id == group_id: return group
for group in self.groups: assert isinstance(group, Group) if group.group_name == group_name: return group
for group in self.groups: assert isinstance(group, Group) for unit in group.units: yield unit
for unit in self.units: assert isinstance(unit, BaseUnit) if unit.unit_name == unit_name: return unit
for unit in self.units: assert isinstance(unit, BaseUnit) if unit.unit_id == unit_id: return unit
Mission.validator_group_category.validate(category, 'group category') for unit in self.units: assert isinstance(unit, BaseUnit) if unit.group_category == category: yield unit
super(Static, self).__init__(mission_dict, l10n, coa_color, country_index) self.static_index = static_index
def static_id(self): return self._section_static['groupId']
def static_id(self, value): valid_int.validate(value, 'groupId') self._section_static['groupId'] = value
def _section_static(self): return self._section_this_country['static']['group'][self.static_index]
def _static_name_key(self): return self._section_static['name']
def static_name(self): return self.l10n[self._static_name_key]
def static_name(self, value): validator_group_or_unit_name.validate(value, 'group name') self.l10n[self._static_name_key] = value
def static_category(self): return self._section_static['units'][1]['category']
def static_is_farp(self): return self.static_category == 'Heliports'
def static_position(self): unit = self._section_static['units'][1] return unit['x'], unit['y']
# noinspection PyProtectedMember
assert isinstance(parent_route, Group.Route) self.parent_route = parent_route
return 'Route({})'.format(self.parent_route.parent_group.group_name)
assert isinstance(parent_group, Group) self.parent_group = parent_group
return 'Route({})'.format(self.parent_group.group_name)
def _section_route(self): return self.parent_group._section_group['route']['points']
def points(self): raise NotImplementedError('uh')
super().__init__(mission_dict, l10n, coa_color, country_index) self.group_category = group_category self.group_index = group_index self.__group_route = None self.__units = {} self.units_class_enum = { 'helicopter': Helicopter, 'plane': Plane, 'ship': Ship, 'vehicle': Vehicle, }
return 'Group({}, {}, {}, {}, {})'.format(self._section_group, self.coa_color, self.country_index, self.group_category, self.group_index)
if not isinstance(other, Group): raise ValueError( '"other" must be an AbstractUnit instance; got: {}'.format(type(other))) return self._section_group == other._section_group
# noinspection PyTypeChecker # TODO if self.__group_route is None: self.__group_route = Group.Route(self) return self.__group_route
def group_route(self, value): self.validator_group_route.validate(value, 'group_route') self.__group_route = value
def _section_group(self): return self._section_this_country[self.group_category]['group'][self.group_index]
def _group_name_key(self): return self._section_group['name']
def group_name(self): return self.l10n[self._group_name_key]
def group_name(self, value): validator_group_or_unit_name.validate(value, 'group name') self.l10n[self._group_name_key] = value
def group_hidden(self): return self._section_group['hidden']
def group_hidden(self, value): valid_bool.validate(value, 'property "hidden" for group') self._section_group['hidden'] = value
def group_id(self): return self._section_group['groupId']
def group_id(self, value): valid_int.validate(value, 'groupId') self._section_group['groupId'] = value
def group_start_delay(self): return self._section_group['start_time']
def group_start_delay(self, value): valid_int.validate(value, 'group_start_delay') if value < 0: raise ValueError(self.group_name) self._section_group['start_time'] = value
def group_start_time(self): return self.group_start_delay + self.mission_start_time
def group_start_time(self, value): valid_int.validate(value, 'group_start_time') self.group_start_delay = value - self.mission_start_time
def group_start_time_as_date(self): return strftime('%d/%m/%Y %H:%M:%S', gmtime(EPOCH_DELTA + self.group_start_time))
def group_start_time_as_date(self, value): Mission.validator_start_date.validate(value, 'start_time_as_date') self.group_start_time = timegm(strptime(value, '%d/%m/%Y %H:%M:%S')) - EPOCH_DELTA
def units(self): for unit_index in self._section_group['units']: if unit_index not in self.__units.keys(): self.__units[unit_index] = self.units_class_enum[self.group_category](self.d, self.l10n, self.coa_color, self.country_index, self.group_category, self.group_index, unit_index) yield self.__units[unit_index]
return list(self.units)[0]
return len(list(self.units))
for unit in self.units: assert isinstance(unit, BaseUnit) if unit.unit_name == unit_name: return unit return None
for unit in self.units: assert isinstance(unit, BaseUnit) if unit.unit_id == unit_id: return unit return None
if unit_index in self._section_group['units'].keys(): if unit_index not in self.__units.keys(): self.__units[unit_index] = self.units_class_enum[self.group_category](self.d, self.l10n, self.coa_color, self.country_index, self.group_category, self.group_index, unit_index) return self.__units[unit_index] return None
def group_is_client_group(self): # TODO create test first_unit = self.get_unit_by_index(1) assert isinstance(first_unit, BaseUnit) return first_unit.skill == 'Client'
def group_start_position(self): return self.group_route._section_route[1]['action']
# noinspection PyProtectedMember _in_list=['Average', 'Good', 'High', 'Excellent', 'Random', 'Client', 'Player'], exc=ValueError, logger=LOGGER)
super().__init__(mission_dict, l10n, coa_color, country_index, group_category, group_index) self.unit_index = unit_index
return '{}({}, {}, {}, {}, {}, {})'.format(self.__class__.__name__, self._section_unit, self.coa_color, self.country_index, self.group_category, self.group_index, self.unit_index)
def _section_unit(self): return self._section_group['units'][self.unit_index]
def _unit_name_key(self): return self._section_unit['name']
def unit_name(self): return self.l10n[self._unit_name_key]
def unit_name(self, value): validator_group_or_unit_name.validate(value, 'unit name') self.l10n[self._unit_name_key] = value
def skill(self): return self._section_unit['skill']
def skill(self, value): self.validator_skill.validate(value, 'unit skill') self._section_unit['skill'] = value
def speed(self): return self._section_unit['speed']
def speed(self, value): valid_float.validate(value, 'unit speed') self._section_unit['speed'] = value
def unit_type(self): return self._section_unit['type']
def unit_type(self, value): self.validator_unit_types.validate(value, 'unit type') self._section_unit['type'] = value
def unit_id(self): return self._section_unit['unitId']
def unit_id(self, value): valid_int.validate(value, 'unitId') self._section_unit['unitId'] = value
def unit_pos_x(self): return float(self._section_unit['x'])
def unit_pos_x(self, value): valid_float.validate(value, 'unit position X coordinate') self._section_unit['x'] = value
def unit_pos_y(self): return float(self._section_unit['y'])
def unit_pos_y(self, value): valid_float.validate(value, 'unit position Y coordinate') self._section_unit['y'] = value
def unit_position(self): return self.unit_pos_x, self.unit_pos_y
def unit_position(self, value): self.unit_pos_x, self.unit_pos_y = value
def heading(self): return self._section_unit['heading']
def heading(self, value): Mission.validator_heading.validate(value, 'unit heading') self._section_unit['heading'] = value
raise TypeError('unit #{}: {}'.format(self.unit_id, self.unit_name))
def has_radio_presets(self): return all([self.skill == 'Client', self.unit_type in FlyingUnit.RadioPresets.radio_enum.keys()])
if not isinstance(other, BaseUnit): raise ValueError( '"other" must be an AbstractUnit instance; got: {}'.format(type(other))) return self._section_unit == other._section_unit
logger=LOGGER)
'Ka-50': { 1: { 'radio_name': 'R828', 'min': 20, 'max': 59.9, 'channels_qty': 10, }, 2: { 'radio_name': 'ARK22', 'min': 0.15, 'max': 1.75, 'channels_qty': 16, }, }, 'Mi-8MT': { 1: { 'radio_name': 'R863', 'min': 100, 'max': 399.9, 'channels_qty': 20, }, 2: { 'radio_name': 'R828', 'min': 20, 'max': 59.9, 'channels_qty': 10, }, }, 'UH-1H': { 1: { 'radio_name': 'ARC51', 'min': 225, 'max': 399.97, 'channels_qty': 20, }, }, 'F-86F Sabre': { 1: { 'radio_name': 'ARC-27', 'min': 225, 'max': 399.9, 'channels_qty': 18, }, }, 'M-2000C': { 1: { 'radio_name': 'UHF', 'min': 225, 'max': 400, 'channels_qty': 20, }, 2: { 'radio_name': 'V/UHF', 'min': 118, 'max': 400, 'channels_qty': 20, }, }, 'MiG-21Bis': { 1: { 'radio_name': 'R-832', 'min': 80, 'max': 399.9, 'channels_qty': 20, }, }, 'P-51D': { 1: { 'radio_name': 'SCR552', 'min': 100, 'max': 156, 'channels_qty': 4, }, }, 'TF-51D': { 1: { 'radio_name': 'SCR552', 'min': 100, 'max': 156, 'channels_qty': 4, }, }, 'SpitfireLFMkIX': { 1: { 'radio_name': 'SCR522', 'min': 100, 'max': 156, 'channels_qty': 4, }, }, 'Bf-109K-4': { 1: { 'radio_name': 'FuG 16 ZY', 'min': 38, 'max': 156, 'channels_qty': 5, }, }, 'FW-190D9': { 1: { 'radio_name': 'FuG 16', 'min': 38.4, 'max': 42.4, 'channels_qty': 4, }, }, 'SA342L': { 1: { 'radio_name': 'FM Radio', 'min': 30, 'max': 87.975, 'channels_qty': 8, }, }, 'SA342M': { 1: { 'radio_name': 'FM Radio', 'min': 30, 'max': 87.975, 'channels_qty': 8, }, }, 'SA342Mistral': { 1: { 'radio_name': 'FM Radio', 'min': 30, 'max': 87.975, 'channels_qty': 8, }, }, }
assert isinstance(parent_unit, FlyingUnit) self.parent_unit = parent_unit self.radio_num = radio_num
if not isinstance(other, FlyingUnit.RadioPresets): raise Exception('cannot compare RadioPreset instance with other object of type {}'.format(type(other))) assert isinstance(other, FlyingUnit.RadioPresets) if not self.radio_name == other.radio_name: return False for channel, frequency in self.channels: if not frequency == other.get_frequency(channel): return False return True
def radio_name(self): return self.radio_enum[self.parent_unit.unit_type][self.radio_num]['radio_name']
def channels_qty(self): return self.radio_enum[self.parent_unit.unit_type][self.radio_num]['channels_qty']
def min(self): return float(self.radio_enum[self.parent_unit.unit_type][self.radio_num]['min'])
def max(self): return float(self.radio_enum[self.parent_unit.unit_type][self.radio_num]['max'])
def _section_radio(self): return self.parent_unit._section_unit['Radio']
def _section_channels(self): return self._section_radio[self.radio_num]['channels']
for k in self._section_channels: yield (k, float(self._section_channels[k]))
valid_positive_int.validate(channel, 'get_frequency') if 1 <= channel <= self.channels_qty: return float(self._section_channels[channel]) else: raise ValueError( 'channel {} for radio {} in aircraft {}'.format(channel, self.radio_name, self.parent_unit.unit_name))
valid_positive_int.validate(channel, 'set_frequency') valid_float.validate(frequency, 'set_frequency') if 1 <= channel <= self.channels_qty: # noinspection PyTypeChecker if self.min <= frequency <= self.max: self._section_channels[channel] = float(frequency) else: raise ValueError( 'frequency {} for channel {} for radio {} in aircraft {}'.format(frequency, channel, self.radio_name, self.parent_unit.unit_name)) else: raise ValueError( 'channel {} for radio {} in aircraft {}'.format(channel, self.radio_name, self.parent_unit.unit_name))
super().__init__(mission_dict, l10n, coa_color, country_index, group_category, group_index, unit_index)
if self.skill == 'Client' and self.unit_type in FlyingUnit.RadioPresets.radio_enum.keys(): for k in self._section_unit['Radio']: yield FlyingUnit.RadioPresets(self, k) else: raise TypeError('unit #{}: {}'.format(self.unit_id, self.unit_name))
def radios(self): try: return self._section_unit['Radio'] except KeyError: raise KeyError(self.unit_type)
if self.has_radio_presets: for k in FlyingUnit.RadioPresets.radio_enum[self.unit_type].keys(): if radio_name == FlyingUnit.RadioPresets.radio_enum[self.unit_type][k]['radio_name']: return FlyingUnit.RadioPresets(self, k) raise TypeError('{} for aircraft: {}'.format(radio_name, self.unit_type)) else: raise TypeError('unit #{}: {}'.format(self.unit_id, self.unit_name))
if self.has_radio_presets: if radio_number in FlyingUnit.RadioPresets.radio_enum[self.unit_type].keys(): return FlyingUnit.RadioPresets(self, radio_number) else: raise TypeError( 'radio number {} for aircraft: {}'.format(radio_number, self.unit_type)) else: raise TypeError('unit #{}: {}'.format(self.unit_id, self.unit_name))
def livery(self): return self._section_unit['livery_id']
def livery(self, value): # TODO validate livery_id valid_str.validate(value, 'unit livery') self._section_unit['livery_id'] = value
def onboard_num(self): return self._section_unit['onboard_num']
def onboard_num(self, value): FlyingUnit.validator_board_number.validate(value, 'unit onboard number') self._section_unit['onboard_num'] = value
super().__init__(mission_dict, l10n, coa_color, country_index, group_category, group_index, unit_index)
super().__init__(mission_dict, l10n, coa_color, country_index, group_category, group_index, unit_index)
super().__init__(mission_dict, l10n, coa_color, country_index, group_category, group_index, unit_index)
super().__init__(mission_dict, l10n, coa_color, country_index, group_category, group_index, unit_index) |