def __init__(self, hide=True): self.hide = hide self.m = dcs.Mission(terrain=dcs.terrain.Nevada()) self.red_airports = [] # type: List[dcs.terrain.Airport] self.blue_airports = [] # type: List[dcs.terrain.Airport] self.setup_airports()
def __init__(self, hide=True): self.hide = hide self.m = dcs.Mission() self.m.coalition["red"].swap_country(self.m.coalition["blue"], dcs.countries.Ukraine.name) self.red_airports = [] # type: List[dcs.terrain.Airport] self.blue_airports = [] # type: List[dcs.terrain.Airport] self.setup_airports()
def test_nav_target_points(self): m = dcs.Mission() batumi = m.terrain.batumi() batumi.set_blue() usa = m.country("USA") jeff = m.flight_group_from_airport(usa, "JF17", dcs.planes.JF_17, group_size=2, airport=m.terrain.batumi()) jeff.set_client() jeff.add_waypoint( m.terrain.batumi().position.point_from_heading(-90, 10000), 600) pp1_pos = batumi.position.point_from_heading(-90, 12000) jeff.add_nav_target_point( batumi.position.point_from_heading(-90, 12000), "PP1") jeff.add_nav_target_point( batumi.position.point_from_heading(-90, 14000), "PP2") jeff.add_nav_target_point( batumi.position.point_from_heading(-90, 16000), "PP3") jeff.add_nav_target_point( batumi.position.point_from_heading(-90, 18000), "PP4") # Test pydcs model self.assertEqual(len(jeff.nav_target_points), 4) self.assertEqual(jeff.nav_target_points[0].text_comment, "PP1") self.assertEqual(jeff.nav_target_points[0].position.x, pp1_pos.x) self.assertEqual(jeff.nav_target_points[0].position.y, pp1_pos.y) self.assertEqual(jeff.nav_target_points[0].index, 1) # Test dict representation self.assertTrue("NavTargetPoints" in jeff.dict().keys()) self.assertTrue( jeff.dict()["NavTargetPoints"][0]["text_comment"] == "PP1") self.assertTrue(jeff.dict()["NavTargetPoints"][0]["x"] == pp1_pos.x) self.assertTrue(jeff.dict()["NavTargetPoints"][0]["y"] == pp1_pos.y) self.assertTrue(jeff.dict()["NavTargetPoints"][0]["index"] == 1) m.save("missions/mission_with_nav_target_points.miz") # load the mission back m2 = dcs.mission.Mission() self.assertTrue( m2.load_file("missions/mission_with_nav_target_points.miz")) usa_miz = m2.country("USA") jeff_miz = usa_miz.find_group("JF17") # Test pydcs model from loaded mission self.assertEqual(len(jeff_miz.nav_target_points), 4) self.assertEqual(jeff_miz.nav_target_points[0].text_comment, "PP1") self.assertEqual(jeff_miz.nav_target_points[0].position.x, pp1_pos.x) self.assertEqual(jeff_miz.nav_target_points[0].position.y, pp1_pos.y) self.assertEqual(jeff_miz.nav_target_points[0].index, 1)
def __init__(self, mission_file): dcs_mission = dcs.Mission() dcs_mission.load_file(mission_file) self.mission = dcs_mission self.cloud_mappings = { "Clear": [ Clouds.LightScattered1, Clouds.LightScattered2, Clouds.HighScattered1, Clouds.HighScattered2, Clouds.HighScattered3, Clouds.Scattered1, Clouds.Scattered2, Clouds.Scattered3, Clouds.Scattered4, Clouds.Scattered5, Clouds.Scattered6, Clouds.Scattered7, ], "Clouds": [ Clouds.Broken1, Clouds.Broken2, Clouds.Broken3, Clouds.Broken4, Clouds.Broken5, Clouds.Broken6, Clouds.Broken7, Clouds.Broken8, ], "Rain": [ Clouds.OvercastAndRain1, Clouds.OvercastAndRain2, Clouds.OvercastAndRain3, ], "Thunderstorm": [ Clouds.Overcast1, Clouds.Overcast2, Clouds.Overcast3, Clouds.Overcast4, Clouds.Overcast5, Clouds.Overcast6, Clouds.Overcast7, ], }
def create_mission() -> Mission: m = dcs.Mission(dcs.terrain.Caucasus()) batumi = m.terrain.batumi() batumi.set_blue() usa = m.country("USA") awacs = m.awacs_flight(usa, "AWACS", dcs.planes.E_3A, batumi, dcs.Point(batumi.position.x + 20000, batumi.position.y + 80000), race_distance=120 * 1000, heading=90) escort = m.escort_flight(usa, "Escort", dcs.planes.F_A_18C, batumi, awacs) escort.load_pylon(dcs.planes.F_A_18C.Pylon2.Mk_82___500lb_GP_Bomb_LD, 2) return m
def main(): parser = argparse.ArgumentParser( description='Tauntaun live editor server.') parser.add_argument('--config', help="path to config.json", type=str) parser.add_argument('--log', help="path to tauntaun.log", type=str) args = parser.parse_args() _setup_logging(args.log) logging.info("--------------------------------------------------") logging.info("Tauntaun started.") try: config.load_config(args.config) c = Campaign() c.mission = dcs.Mission(terrain.Caucasus()) session_manager = SessionManager() if config.config.default_mission: logging.info("Using default mission set in config") defualt_miz_path = os.path.join( get_miz_path(), config.config.default_mission + ".miz") else: defualt_miz_path = _build_in_default_mission if os.path.isfile(defualt_miz_path): c.load_mission(defualt_miz_path) else: logging.warning( "Unable to load default mission, using empty mission!") batumi = c.mission.terrain.batumi() batumi.set_blue() server.run(c, session_manager, 8080) except Exception as e: logging.exception('Got exception on main handler') logging.info("Tauntaun stopped gracefully.") logging.info("--------------------------------------------------")
def __init__(self, aircraft_types: List[Tuple[str, str]], playercount: int, start: str, unhide): self.m = dcs.Mission(terrain=dcs.terrain.Nevada()) self.red_airports = [] # type: List[dcs.terrain.Airport] self.blue_airports = [] # type: List[dcs.terrain.Airport] self.setup_airports() nevada = self.m.terrain # type: dcs.terrain.Nevada self.add_civil_airtraffic(hidden=not unhide, airports_to_use=[ nevada.mccarran_international_airport(), nevada.henderson_executive_airport(), nevada.boulder_city_airport()]) usa = self.m.country(dcs.countries.USA.name) nellis = nevada.nellis_afb() creech = nevada.creech_afb() groom = nevada.groom_lake_afb() blue_military = [nellis, creech, groom] planes = [ (dcs.countries.USA.name, dcs.countries.USA.Plane.F_16C_bl_52d, 4), (dcs.countries.USA.name, dcs.countries.USA.Plane.F_15E, 2), (dcs.countries.USA.name, dcs.countries.USA.Plane.F_A_18C, 4), (dcs.countries.USA.name, dcs.countries.USA.Plane.A_10A, 4) ] self.add_uncontrolled_military_planes(blue_military, planes, False) self.add_ground_targets() awacs_frequency = 130 tanker_frequency = 140 orbit_rect = dcs.mapping.Rectangle( int(creech.position.x), int(creech.position.y - 100 * 1000), int(creech.position.x - 100 * 1000), int(creech.position.y)) pos, heading, race_dist = TrainingScenario.random_orbit(orbit_rect) awacs = self.m.awacs_flight( usa, "AWACS", plane_type=dcs.planes.E_3A, airport=None, position=pos, race_distance=race_dist, heading=heading, altitude=random.randrange(4000, 5500, 100), frequency=awacs_frequency) self.m.escort_flight(usa, "AWACS Escort", dcs.countries.USA.Plane.F_15E, None, awacs, group_size=2) pos, heading, race_dist = TrainingScenario.random_orbit(orbit_rect) refuel_net = self.m.refuel_flight( usa, "Tanker KC_130", dcs.planes.KC130, airport=None, position=pos, race_distance=race_dist, heading=heading, altitude=random.randrange(4000, 5500, 100), speed=750, frequency=tanker_frequency) pos, heading, race_dist = TrainingScenario.random_orbit(orbit_rect) refuel_rod = self.m.refuel_flight( usa, "Tanker KC_135", dcs.planes.KC_135, airport=None, position=pos, race_distance=race_dist, heading=heading, altitude=random.randrange(4000, 5500, 100), frequency=tanker_frequency, tacanchannel="12X") player_groups = self.place_players(start, aircraft_types, blue_military, placement_rect=dcs.Rectangle.from_point(groom.position, 20 * 1000), group_size=playercount, maintask=None) if start == "inflight": fuel_percent = 0.2 else: fuel_percent = 0.3 airport = None # type: dcs.terrain.Airport pg = None # type: dcs.unitgroup.FlyingGroup for pg in player_groups: airport = self.m.terrain.airport_by_id(pg.points[0].airdrome_id) if not airport: airport = random.choice(blue_military) for u in pg.units: u.fuel *= fuel_percent if not pg.units[0].unit_type.helicopter: if pg.units[0].unit_type in [dcs.planes.A_10C]: pg.add_waypoint(refuel_rod.points[1].position, 4000) else: pg.add_waypoint(refuel_net.points[1].position, 4000) pg.add_runway_waypoint(airport) pg.land_at(airport) pg.load_loadout("Combat Air Patrol") goal = dcs.goals.Goal("home and alive") goal.rules.append(dcs.condition.UnitAlive(pg.units[0].id)) tz = self.m.triggers.add_triggerzone(airport.position, 1000, name="home") goal.rules.append((dcs.condition.UnitInZone(pg.units[0].id, tz.id))) self.m.goals.add_offline(goal) self.m.set_sortie_text("Training mission nevada.") self.m.set_description_text("""Random generated training mission. {count} {type} are/is prepared for a refueling training mission.""".format( count=playercount, type=", ".join([x[1] for x in aircraft_types]))) self.m.set_description_bluetask_text("""Find your tanker and do a full refuel. Afterwards land at your designated homebase. AWACS is reachable on {awacs_freq} Mhz VHF-AM and Tankers are reachable on {tanker_freq} Mhz VHF-AM. KC-135 Tanker has TACAN 12X and KC-130 has TACAN 10X.""".format( awacs_freq=awacs_frequency, tanker_freq=tanker_frequency))
import os import sys import dcs from game import db from gen.aircraft import AircraftConflictGenerator dcs.planes.FlyingType.payload_dirs = [ os.path.join(os.path.dirname(os.path.realpath(__file__)), "..\\payloads") ] mis = dcs.Mission(dcs.terrain.PersianGulf()) pos = dcs.terrain.PersianGulf().khasab().position airgen = AircraftConflictGenerator(mis, None, None, None) for t, uts in db.UNIT_BY_TASK.items(): if t != dcs.task.CAP and t != dcs.task.CAS: continue pos.y = dcs.terrain.PersianGulf().khasab().position.x for t in t == dcs.task.CAP and [dcs.task.CAP, dcs.task.Escort] or [t]: pos.x += 10000 for ut in uts: pos.y += 5000 ctr = mis.country([ v["country"] for k, v in db.FACTIONS.items() if ut in v["units"] ][0]) g = mis.flight_group_inflight(country=ctr, name="{} - {}".format(t.name, ut),
def main(): aircrafts = [x for x in dcs.planes.plane_map.values() if x.flyable] helicopters = [ x for x in dcs.helicopters.helicopter_map.values() if x.flyable ] aircraft_types = [x.id for x in aircrafts + helicopters] parser = argparse.ArgumentParser( description="DCS random search and destroy oil convoy") parser.add_argument("-a", "--aircrafttype", default=dcs.planes.A_10C.id, choices=aircraft_types, help="Player aircraft type") parser.add_argument("-u", "--unhide", action="store_true", default=False, help="Show enemy pre mission") parser.add_argument("-t", "--terrain", choices=["caucasus", "nevada"], default='caucasus') parser.add_argument("-d", "--difficulty", choices=["easy", "normal", "hard", "ohno"], default='normal') parser.add_argument("-m", "--multiplayer", action="store_true", default=False) parser.add_argument("-s", "--stats", action="store_false", default=True) parser.add_argument("-o", "--output", help="Name and path of the generated mission", default=None) args = parser.parse_args() terrain_map = { "caucasus": dcs.terrain.Caucasus, "nevada": dcs.terrain.Nevada } difficulty_map = {'easy': 0.25, 'normal': 0.5, 'hard': 0.7, 'ohno': 0.9} difficulty = difficulty_map[args.difficulty] if args.output is None: if args.terrain == "caucasus": args.output = os.path.join( os.path.expanduser("~"), "Saved Games\\DCS\\Missions\\oil_transport.miz") zone_enemy = zone_abkhazia destination_city = 'Adler' else: args.output = os.path.join( os.path.expanduser("~"), "Saved Games\\DCS.openalpha\\Missions\\oil_transport.miz") m = dcs.Mission(terrain_map[args.terrain]()) m.random_weather = True m.random_date() m.random_daytime('day') for a in m.terrain.default_red_airports(): a.set_red() for b in m.terrain.default_blue_airports(): b.set_blue() city_graph = m.terrain.city_graph destination_node = city_graph.node(destination_city) # find a startnode far away enough start_node = random.choice(city_graph.rated_nodes_within(zone_enemy)) while start_node.position.distance_to_point( destination_node.position) < 70000: start_node = random.choice(city_graph.rated_nodes_within(zone_enemy)) # create the oil convoy abkhazia = m.country(dcs.countries.Abkhazia.name) convoy_vehicles = [] for i in range(0, 1 + int(max(difficulty, random.random()) * 10)): convoy_vehicles.append(dcs.vehicles.Unarmed.Fuel_Truck_ATZ_10) airdef = [ dcs.countries.Abkhazia.Vehicle.AirDefence.AAA_ZU_23_on_Ural_375, dcs.countries.Abkhazia.Vehicle.AirDefence.SPAAA_ZSU_23_4_Shilka ] if random.random() < difficulty: convoy_vehicles.append(random.choice(airdef)) oil_convoy = m.vehicle_group_platoon( abkhazia, "Oil Convoy", convoy_vehicles, start_node.position.random_point_within(50)) oil_convoy.hidden = not args.unhide oil_convoy.points[0].tasks.append(dcs.task.OptDisparseUnderFire()) oil_convoy.set_skill(dcs.unit.Skill.from_percentage(difficulty)) oil_convoy.formation_scattered(0, 50) oil_convoy.add_waypoint(start_node.position, dcs.point.PointAction.OnRoad) _, path = city_graph.travel(oil_convoy, start_node, destination_node, 100) # add light air defence around and in cities on path aaa_def = [ [dcs.countries.Abkhazia.Vehicle.AirDefence.AAA_ZU_23_Emplacement], [ dcs.countries.Abkhazia.Vehicle.AirDefence.SAM_SA_18_Igla_MANPADS, dcs.countries.Abkhazia.Vehicle.AirDefence.SAM_SA_18_Igla_comm ] ] for city in city_graph.rated_nodes_within(zone_enemy, 50): use_building_pos = int( min(difficulty, random.random()) * len(city.air_defence_pos_small)) small_aaa_pos = list(city.air_defence_pos_small) for i in range(0, use_building_pos): p = small_aaa_pos.pop(random.randrange(0, len(small_aaa_pos))) vg = m.vehicle_group_platoon( abkhazia, city.name + " AAA #" + str(len(small_aaa_pos)), random.choice(aaa_def), p, 0) vg.set_skill(dcs.unit.Skill.from_percentage(difficulty)) vg.hidden = not args.unhide vg.formation_scattered(random.randrange(0, 360), 15) aaa_def += [[ dcs.countries.Abkhazia.Vehicle.AirDefence.SPAAA_ZSU_23_4_Shilka, dcs.countries.Abkhazia.Vehicle.Armor.ARV_BRDM_2, dcs.countries.Abkhazia.Vehicle.Armor.ARV_BRDM_2 ]] for node in city_graph.nodes_within(zone_enemy): if random.random() < (difficulty - 0.1): vg = m.vehicle_group_platoon( abkhazia, node.name, random.choice(aaa_def), node.position.random_point_within(100, 30), random.randrange(0, 360)) vg.set_skill(dcs.unit.Skill.from_percentage(difficulty)) vg.hidden = not args.unhide # add a buk site if difficulty is hard or higher if difficulty > 0.5: buk_node = random.choice(city_graph.rated_nodes_within(zone_enemy, 50)) sa11 = dcs.templates.VehicleTemplate.sa11_site( m, abkhazia, buk_node.position.random_point_within(80, 30), 120, skill=dcs.unit.Skill.from_percentage(difficulty)) sa11.hidden = not args.unhide usa = m.country('USA') # place farp for helis zugdidi_ne = city_graph.node('Zugidi NE') farp = m.farp(usa, "FARP Zugdidi", zugdidi_ne.position + dcs.mapping.Point(0, 500)) fg = m.flight_group_from_unit(usa, dcs.helicopters.Ka_50.id + " Client", dcs.helicopters.Ka_50, farp, dcs.task.CAS, group_size=2) fg.set_client() farp = m.farp(usa, "FARP Kvemo", zugdidi_ne.position + dcs.mapping.Point(0, -22 * 1000)) fg = m.flight_group_from_unit(usa, dcs.helicopters.UH_1H.id + " Client", dcs.helicopters.UH_1H, farp, dcs.task.CAS, group_size=2) fg.set_client() # place player player_fg = None if args.multiplayer: for x in aircrafts: if dcs.task.CAS in x.tasks and x not in [ dcs.planes.Su_33, dcs.planes.MiG_29A, dcs.planes.MiG_29S ]: country = m.country(dcs.countries.Georgia.name) if x in [ dcs.planes.Su_25T, dcs.planes.Su_25 ] else usa fg = m.flight_group_from_airport(country, x.id + " Client", x, m.terrain.senaki(), dcs.task.CAS, group_size=2) fg.add_runway_waypoint(m.terrain.senaki()) fg.set_client() else: aircraft_type = [x for x in aircrafts if x.id == args.aircrafttype][0] player_fg = m.flight_group_from_airport(usa, "Player", aircraft_type, m.terrain.senaki(), dcs.task.CAS) player_fg.add_runway_waypoint(m.terrain.senaki()) player_fg.units[0].set_player() # CAP flight cap_type = random.choice( [dcs.planes.F_16C_bl_52d, dcs.planes.F_A_18C, dcs.planes.F_15E]) m.patrol_flight( usa, "CAP", cap_type, m.terrain.kutaisi(), zugdidi_ne.position, zugdidi_ne.position.point_from_heading(random.randint(270, 350), 35 * 1000)) notify_nodes = path[1:5] for i in range(0, int((1.3 - difficulty) * 3)): notifier_node = random.randrange(0, len(notify_nodes)) notifier_node = city_graph.node(notify_nodes.pop(notifier_node)) notify_zone = m.triggers.add_triggerzone(notifier_node.position, 300, hidden=False, name='notify_zone') notify_zone.hidden = True trig_notify = dcs.triggers.TriggerOnce( comment='NotifyConvoyPosition #' + str(i)) trig_notify.rules.append( dcs.condition.PartOfGroupInZone(oil_convoy.id, notify_zone.id)) trig_notify.actions.append( dcs.action.MessageToCoalition( dcs.action.Coalition.Blue, m.string( 'Intel just reported that the convoy just arrived at ' + notifier_node.name), 20)) m.triggerrules.triggers.append(trig_notify) trig_convoy_dead = dcs.triggers.TriggerOnce(dcs.triggers.Event.Destroy, comment='Convoy dead') trig_convoy_dead.rules.append(dcs.condition.GroupDead(oil_convoy.id)) trig_convoy_dead.actions.append( dcs.action.MessageToCoalition( dcs.action.Coalition.Blue, m.string( 'Excellent job!\nIntelligence reports the convoy was destroyed!\nRTB' ), 15)) m.triggerrules.triggers.append(trig_convoy_dead) m.forced_options.civil_traffic = dcs.forcedoptions.ForcedOptions.CivilTraffic.Low g = dcs.goals.Goal("convoy destroyed", score=100) g.rules.append(dcs.condition.GroupDead(oil_convoy.id)) if player_fg: g.rules.append(dcs.condition.GroupAlive(player_fg.id)) m.goals.add_blue(g) m.goals.add_offline(g) m.set_sortie_text("Search and destroy the oil convoy") m.set_description_text( """Abkhazia is selling oil to Russia to silently finance their military investments. US and Georgia forces decided to prevent these oil transports.""") m.set_description_bluetask_text( """You are tasked to search and destroy a current oil convoy. The position of the convoy is unknown, but we have several agents in Abkhazia that will look out for the current route of the oil convoy. Last known position will be transmitted to you while in flight. Keep in mind that there are man pads and several AAA air defences around cities in Abkazia that are just waiting to shoot down an American or Georgian aircraft. Mission objectives: * Find the convoy * Destroy the convoy * Head back in one piece to Senaki airport.""") if args.stats: m.print_stats(m.stats()) m.save(args.output) return 0
def test_create_mission_with_marks(self): m = dcs.Mission() batumi = m.terrain.batumi() batumi.set_blue() kutaisi = m.terrain.kutaisi() kutaisi.set_red() usa = m.country("USA") rus = m.country("Russia") # Create some group to use if you want to check visibility of marks in game su25_group = m.flight_group_from_airport(usa, "SU25", dcs.planes.Su_25T, group_size=1, airport=m.terrain.batumi()) su25_group.set_client() f15_group = m.flight_group_from_airport(usa, "F15C", dcs.planes.F_15C, group_size=1, airport=m.terrain.batumi()) f15_group.set_client() su25_red_group = m.flight_group_from_airport( rus, "SU25 RED", dcs.planes.Su_25T, group_size=1, airport=m.terrain.kutaisi()) su25_red_group.set_client() # In DCS, you have to create a trigger zone to add a mark. # This mark will be visible for all (after 2 sec) mark_all_pos = batumi.position.point_from_heading(-90, 12000) mark_all_zone = m.triggers.add_triggerzone(mark_all_pos, 1, False, "MARK TO ALL ZONE") mark_all_trigger = dcs.triggers.TriggerOnce( comment="Create Mark for ALL") mark_all_trigger.add_condition(dcs.condition.TimeAfter(2)) mark_all_trigger.add_action( dcs.action.MarkToAll(10, mark_all_zone.id, m.string("Mark to all"), m.string("Mark to all has been added"), 1000, True)) m.triggerrules.triggers.append(mark_all_trigger) # This mark will be visible for blue coalition only (after 5 sec) mark_blue_pos = batumi.position.point_from_heading(-90, 24000) mark_blue_zone = m.triggers.add_triggerzone( mark_blue_pos, 1, False, "MARK TO BLUE COALITION ZONE") mark_blue_trigger = dcs.triggers.TriggerOnce( comment="Create Mark for BLUE") mark_blue_trigger.add_condition(dcs.condition.TimeAfter(5)) mark_blue_trigger.add_action( dcs.action.MarkToCoalition( 11, mark_blue_zone.id, dcs.action.Coalition.Blue, m.string("Mark to Blue"), m.string("Mark to Blue coalition has been added"), 2000, True)) m.triggerrules.triggers.append(mark_blue_trigger) # This mark will be visible for red coalition only (after 8 sec) mark_red_pos = batumi.position.point_from_heading( -90, 24000).point_from_heading(0, 5000) mark_red_zone = m.triggers.add_triggerzone( mark_red_pos, 1, False, "MARK TO RED COALITION ZONE") mark_red_trigger = dcs.triggers.TriggerOnce( comment="Create Mark for RED") mark_red_trigger.add_condition(dcs.condition.TimeAfter(8)) mark_red_trigger.add_action( dcs.action.MarkToCoalition( 12, mark_red_zone.id, dcs.action.Coalition.Red, m.string("Mark to RED"), m.string("Mark to Red coalition has been added"), 3000, True)) m.triggerrules.triggers.append(mark_red_trigger) # This mark will be visible for the F15 group only (after 11 sec) mark_f15_pos = batumi.position.point_from_heading( -90, 12000).point_from_heading(0, 5000) mark_f15_zone = m.triggers.add_triggerzone(mark_f15_pos, 1, False, "MARK TO F15 ZONE") mark_f15_trigger = dcs.triggers.TriggerOnce( comment="Create Mark for F15") mark_f15_trigger.add_condition(dcs.condition.TimeAfter(11)) mark_f15_trigger.add_action( dcs.action.MarkToGroup( 13, mark_f15_zone.id, f15_group.id, m.string("Mark to F15"), m.string("Mark to F15 group has been added"), 4000, False)) m.triggerrules.triggers.append(mark_f15_trigger) self.assertEqual(len(m.triggerrules.triggers), 4) self.assertEqual(mark_all_trigger.actions[0].dict()["zone"], mark_all_zone.id) self.assertEqual(mark_all_trigger.actions[0].dict()["value"], 10) self.assertEqual(mark_all_trigger.actions[0].dict()["meters"], 1000) self.assertEqual(mark_all_trigger.actions[0].dict()["readonly"], True) self.assertEqual(mark_blue_trigger.actions[0].dict()["zone"], mark_blue_zone.id) self.assertEqual(mark_blue_trigger.actions[0].dict()["coalitionlist"], dcs.action.Coalition.Blue.value) self.assertEqual(mark_blue_trigger.actions[0].dict()["value"], 11) self.assertEqual(mark_blue_trigger.actions[0].dict()["meters"], 2000) self.assertEqual(mark_blue_trigger.actions[0].dict()["readonly"], True) self.assertEqual(mark_red_trigger.actions[0].dict()["zone"], mark_red_zone.id) self.assertEqual(mark_red_trigger.actions[0].dict()["coalitionlist"], dcs.action.Coalition.Red.value) self.assertEqual(mark_red_trigger.actions[0].dict()["value"], 12) self.assertEqual(mark_red_trigger.actions[0].dict()["meters"], 3000) self.assertEqual(mark_red_trigger.actions[0].dict()["readonly"], True) self.assertEqual(mark_f15_trigger.actions[0].dict()["zone"], mark_f15_zone.id) self.assertEqual(mark_f15_trigger.actions[0].dict()["group"], f15_group.id) self.assertEqual(mark_f15_trigger.actions[0].dict()["value"], 13) self.assertEqual(mark_f15_trigger.actions[0].dict()["meters"], 4000) self.assertEqual(mark_f15_trigger.actions[0].dict()["readonly"], False) m.save("missions/mission_with_marks_triggers.miz")
def create_mission(campaign): m = dcs.Mission(terrain.Caucasus()) # setup airports for name, airport in campaign.airports.items(): coal_name = airport.coalition.value print(coal_name) assert (m.terrain.airports[name].set_coalition(coal_name)) usa = m.country("USA") russia = m.country("Russia") sochi = m.terrain.sochi_adler() ship_pos = sochi.position - dcs.Point(50000, 50000) print(f"{sochi.position=}") print(f"{ship_pos=}") cvbg = m.ship_group(country=usa, name="CVN 74 Stennis", _type=ships.CVN_74_John_C__Stennis, position=ship_pos) tasks = cvbg.points[0].tasks tasks.append(ActivateICLSCommand(unit_id=cvbg.id, channel=5)) tasks.append( ActivateBeaconCommand(unit_id=cvbg.id, channel=69, callsign="STN", aa=False)) cvbg.add_waypoint(ship_pos + dcs.Point(0, -100 * 1000)) cvbg.add_waypoint(ship_pos + dcs.Point(-30 * 1000, -100 * 1000)) cvbg.add_waypoint(ship_pos + dcs.Point(-30 * 1000, 0)) # cvbg.add_waypoint(ship_pos) # cvbg.add_waypoint(ship_pos + dcs.Point(0, -100*1000)) # cvbg.add_waypoint(ship_pos + dcs.Point(-30*1000, -100*1000)) # cvbg.add_waypoint(ship_pos + dcs.Point(-30*1000, 0)) # cvbg.add_waypoint(ship_pos) name = namegen.next_unit_name(usa) fg = m.flight_group_from_unit(country=usa, name=name, aircraft_type=planes.FA_18C_hornet, maintask=None, start_type=StartType.Warm, pad_group=cvbg, group_size=4) fg.set_client() offset = dcs.Point(random() * 1000.0, random() * 1000.0) orientation = random() * 360. sa2_pos = sochi.position + offset p = fg.add_waypoint(ship_pos + dcs.Point(1000, 3000), feet_to_meters(8000)) pos = point_along_route(p.position, sochi.position, 50 * 2000) p = fg.add_waypoint(pos, feet_to_meters(26000)) fg.add_waypoint(point_along_route(p.position, sochi.position, -1000), feet_to_meters(26000)) fg.land_at(cvbg) make_sa2_site(m, russia, sa2_pos, orientation) awacs = m.awacs_flight(usa, "AWACS", planes.E_3A, None, dcs.Point(sochi.position.x + 20000, sochi.position.y + 80000), race_distance=80 * 1000, heading=90, speed=knots_to_kph(500), altitude=feet_to_meters(30000)) tasks = awacs.points[0].tasks tasks.append(EPLRS()) campaign.mission = m return m
def main(): red = [ (dcs.countries.Germany.name, dcs.countries.Germany.Plane.Bf_109K_4.id), (dcs.countries.Germany.name, dcs.countries.Germany.Plane.FW_190D9.id), ] blue = [ (dcs.countries.USA.name, dcs.countries.USA.Plane.P_51D.id) ] types = red + blue aircraft_types = [x[1] for x in types] parser = argparse.ArgumentParser(description="DCS WWII dogfight generator") parser.add_argument("-a", "--aircrafttype", default=dcs.planes.Bf_109K_4.id, choices=aircraft_types, help="Player aircraft type") parser.add_argument("-p", "--playercount", default=1, type=int) parser.add_argument("-n", "--numberplanes", default=16, type=int, help="Count of planes per side") parser.add_argument("-t", "--terrain", choices=["caucasus", "nevada"], default='caucasus') parser.add_argument("-s", "--skill", choices=[x.value for x in dcs.unit.Skill], default=dcs.unit.Skill.Average.value) parser.add_argument("-o", "--output", help="Name and path of the generated mission", default=None) args = parser.parse_args() terrain_map = { "caucasus": dcs.terrain.Caucasus, "nevada": dcs.terrain.Nevada } if args.output is None: if args.terrain == "caucasus": args.output = os.path.join(os.path.expanduser("~"), "Saved Games\\DCS\\Missions\\dogfight_wwii.miz") else: args.output = os.path.join(os.path.expanduser("~"), "Saved Games\\DCS.openalpha\\Missions\\dogfight_wwii.miz") m = dcs.Mission(terrain_map[args.terrain]()) m.coalition["blue"].swap_country(m.coalition["red"], dcs.countries.Germany.name) # pick a random airport as fight reference airport = random.choice(list(m.terrain.airport_list())) battle_point = dcs.Rectangle.from_point(airport.position, 40 * 1000).random_point() heading = random.randrange(0, 360) # set editor mapview m.map.position = battle_point m.map.zoom = 100000 # fight altitude altitude = random.randrange(2000, 6000, 100) if args.playercount == 1: player_country = m.country([x[0] for x in types if x[1] == args.aircrafttype][0]) hdg = heading + 180 if m.is_blue(player_country) else heading fg = m.flight_group_inflight(player_country, "Player " + args.aircrafttype, dcs.planes.plane_map[args.aircrafttype], position=battle_point.point_from_heading(hdg, 10 * 800), altitude=altitude, speed=500, maintask=dcs.task.Intercept) fg.add_waypoint(battle_point, altitude=altitude) fg.units[0].set_player() else: for x in types: country = m.country(x[0]) hdg = heading + 180 if m.is_blue(country) else heading pos = battle_point.point_from_heading(hdg, 10 * 800) pos = pos.point_from_heading(hdg + 90, random.randrange(-5000, 5000, 100)) fg = m.flight_group_inflight(country, x[1] + " group", dcs.planes.plane_map[x[1]], position=pos, altitude=random.randrange(altitude - 200, altitude + 200), speed=500, maintask=dcs.task.FighterSweep, group_size=args.playercount) fg.set_client() fg.add_waypoint(battle_point, altitude=altitude) # spawn AI group_count = int(args.numberplanes / 4) last_group_size = args.numberplanes % 4 for c in [red, blue]: gc = 1 for x in range(0, group_count): planetype = random.choice(c) country = m.country(planetype[0]) hdg = heading + 180 if m.is_blue(country) else heading pos = battle_point.point_from_heading(hdg, 10 * 800) pos = pos.point_from_heading(hdg + 90, random.randrange(-5000, 5000, 100)) fg = m.flight_group_inflight(country, planetype[0] + " " + planetype[1] + " #" + str(gc), dcs.planes.plane_map[planetype[1]], position=pos, altitude=random.randrange(altitude - 400, altitude + 400, 50), speed=500, maintask=dcs.task.FighterSweep, group_size=4) fg.set_skill(dcs.unit.Skill(args.skill)) fg.add_waypoint(battle_point, altitude=altitude) gc += 1 if last_group_size: planetype = random.choice(c) country = m.country(planetype[0]) hdg = heading + 180 if m.is_blue(country) else heading pos = battle_point.point_from_heading(hdg, 10 * 800) pos = pos.point_from_heading(hdg + 90, random.randrange(-5000, 5000, 100)) fg = m.flight_group_inflight(m.country(planetype[0]), planetype[0] + " " + planetype[1] + " #" + str(gc), dcs.planes.plane_map[planetype[1]], position=pos, altitude=random.randrange(altitude - 400, altitude + 400, 50), speed=500, maintask=dcs.task.FighterSweep, group_size=last_group_size) fg.set_skill(dcs.unit.Skill(args.skill)) fg.add_waypoint(battle_point, altitude=altitude) m.set_sortie_text("WWII dogfight") stats = m.stats() m.set_description_text("""A WWII dogfight encounter There are {pc} planes in the air battling for life and death.""".format( pc=stats["red"]["plane_groups"]["unit_count"] + stats["blue"]["plane_groups"]["unit_count"])) m.set_description_redtask_text("Fight the other planes!") m.set_description_bluetask_text("Fight the other planes!") m.save(args.output) print("Mission created: " + args.output) return 0
import dcs as pydcs """ This file reads the current liberation mission and generates a log file reporting a player having killed all the enemy ground units (static and vehicle) The purpose is to permit easy debugging without having to actually go and fly missions File isn't really created to be generic or anything, but atm I'm too lazy to update it """ mission = pydcs.Mission() mission.load_file( 'C:\\users\\tim\\Saved Games\\DCS.openbeta\\Missions\\liberation_nextturn.miz' ) # find the player player_id = None player_name = None enemy_units = [] for country in mission.coalition['blue'].countries: for plane_group in mission.coalition['blue'].country(country).plane_group: for plane in plane_group.units: if plane.skill.name == 'Player': player_id = plane.id player_name = plane.name # find enemy units for country in mission.coalition['red'].countries: for unit_group in mission.coalition['red'].country(country).vehicle_group: for unit in unit_group.units: enemy_units.append(unit.id)
def _load_from_miz(self, miz: str, mappings: list[LayoutMapping]) -> None: template_position: dict[str, Point] = {} temp_mis = dcs.Mission() with logged_duration(f"Parsing {miz}"): # The load_file takes a lot of time to compute. That's why the layouts # are written to a pickle and can be reloaded from the ui # Example the whole routine: 0:00:00.934417, # the .load_file() method: 0:00:00.920409 temp_mis.load_file(miz) for mapping in mappings: # Find the group from the mapping in any coalition for country in itertools.chain( temp_mis.coalition["red"].countries.values(), temp_mis.coalition["blue"].countries.values(), ): for dcs_group in itertools.chain( temp_mis.country(country.name).vehicle_group, temp_mis.country(country.name).ship_group, temp_mis.country(country.name).static_group, ): try: g_id, group_name, group_mapping = mapping.group_for_name( dcs_group.name) except KeyError: continue if not isinstance(dcs_group, StaticGroup) and max( group_mapping.unit_count) > len(dcs_group.units): logging.error( f"Incorrect unit_count found in Layout {mapping.name}-{group_mapping.name}" ) layout = self._layouts.get(mapping.name, None) if layout is None: # Create a new template layout = TEMPLATE_TYPES[mapping.primary_role]( mapping.name, mapping.description) layout.generic = mapping.generic layout.tasks = mapping.tasks self._layouts[layout.name] = layout for i, unit in enumerate(dcs_group.units): group_layout = None for group in layout.all_groups: if group.name == group_mapping.name: # We already have a layoutgroup for this dcs_group group_layout = group if not group_layout: group_layout = TgoLayoutGroup( group_mapping.name, [], group_mapping.unit_count, group_mapping.unit_types, group_mapping.unit_classes, group_mapping.fallback_classes, ) group_layout.optional = group_mapping.optional group_layout.fill = group_mapping.fill # Add the group at the correct index layout.add_layout_group(group_name, group_layout, g_id) layout_unit = LayoutUnit.from_unit(unit) if i == 0 and layout.name not in template_position: template_position[layout.name] = unit.position layout_unit.position = (layout_unit.position - template_position[layout.name]) group_layout.layout_units.append(layout_unit)