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)
