コード例 #1
0
    def commision_strike(self):
        """
        Pick some aircraft to assign them to STRIKE tasks
        """
        possible_aircraft = [
            k for k, v in self.aircraft_inventory.items()
            if k in STRIKE_CAPABLE and v >= 2
        ]
        inventory = dict({
            k: v
            for k, v in self.aircraft_inventory.items()
            if k in possible_aircraft
        })

        if len(self.potential_strike_targets) > 0:

            offset = random.randint(0, 5)
            for i in range(
                    int(MISSION_DURATION /
                        self.doctrine["STRIKE_EVERY_X_MINUTES"])):

                if len(self.potential_strike_targets) <= 0:
                    break

                try:
                    unit = random.choice(
                        [k for k, v in inventory.items() if v >= 2])
                except IndexError:
                    break

                if unit in DRONES:
                    count = 1
                else:
                    count = 2

                inventory[unit] = inventory[unit] - count
                flight = Flight(unit, count, self.from_cp, FlightType.STRIKE)

                flight.points = []
                flight.scheduled_in = offset + i * random.randint(
                    self.doctrine["STRIKE_EVERY_X_MINUTES"] - 5,
                    self.doctrine["STRIKE_EVERY_X_MINUTES"] + 5)

                location = self.potential_strike_targets[0][0]
                self.potential_strike_targets.pop(0)

                self.generate_strike(flight, location)

                self.strike_flights.append(flight)
                self.flights.append(flight)

            # Update inventory
            for k, v in inventory.items():
                self.aircraft_inventory[k] = v
コード例 #2
0
    def commision_cas(self):
        """
        Pick some aircraft to assign them to CAS
        """

        possible_aircraft = [
            k for k, v in self.aircraft_inventory.items()
            if k in CAS_CAPABLE and v >= 2
        ]
        inventory = dict({
            k: v
            for k, v in self.aircraft_inventory.items()
            if k in possible_aircraft
        })
        cas_location = self._get_cas_locations()

        if len(cas_location) > 0:

            offset = random.randint(0, 5)
            for i in range(
                    int(MISSION_DURATION /
                        self.doctrine["CAS_EVERY_X_MINUTES"])):

                try:
                    unit = random.choice(
                        [k for k, v in inventory.items() if v >= 2])
                except IndexError:
                    break

                inventory[unit] = inventory[unit] - 2
                flight = Flight(unit, 2, self.from_cp, FlightType.CAS)
                flight.points = []
                flight.scheduled_in = offset + i * random.randint(
                    self.doctrine["CAS_EVERY_X_MINUTES"] - 5,
                    self.doctrine["CAS_EVERY_X_MINUTES"] + 5)
                location = random.choice(cas_location)

                self.generate_cas(flight, flight.from_cp, location)

                self.cas_flights.append(flight)
                self.flights.append(flight)

            # Update inventory
            for k, v in inventory.items():
                self.aircraft_inventory[k] = v
コード例 #3
0
    def commision_cap(self):
        """
        Pick some aircraft to assign them to defensive CAP roles (BARCAP)
        """

        possible_aircraft = [
            k for k, v in self.aircraft_inventory.items()
            if k in CAP_CAPABLE and v >= 2
        ]
        inventory = dict({
            k: v
            for k, v in self.aircraft_inventory.items()
            if k in possible_aircraft
        })

        offset = random.randint(0, 5)
        for i in range(
                int(MISSION_DURATION / self.doctrine["CAP_EVERY_X_MINUTES"])):

            try:
                unit = random.choice(
                    [k for k, v in inventory.items() if v >= 2])
            except IndexError:
                break

            inventory[unit] = inventory[unit] - 2
            flight = Flight(unit, 2, self.from_cp, FlightType.CAP)

            flight.points = []
            flight.scheduled_in = offset + i * random.randint(
                self.doctrine["CAP_EVERY_X_MINUTES"] - 5,
                self.doctrine["CAP_EVERY_X_MINUTES"] + 5)

            if len(self._get_cas_locations()) > 0:
                enemy_cp = random.choice(self._get_cas_locations())
                self.generate_frontline_cap(flight, flight.from_cp, enemy_cp)
            else:
                self.generate_barcap(flight, flight.from_cp)

            self.cap_flights.append(flight)
            self.flights.append(flight)

        # Update inventory
        for k, v in inventory.items():
            self.aircraft_inventory[k] = v
コード例 #4
0
    def commision_interceptors(self):
        """
        Pick some aircraft to assign them to interception roles
        """

        # At least try to generate one interceptor group
        number_of_interceptor_groups = min(
            max(
                sum([v for k, v in self.aircraft_inventory.items()]) / 4,
                self.doctrine["MAX_NUMBER_OF_INTERCEPTION_GROUP"]), 1)
        possible_interceptors = [
            k for k in self.aircraft_inventory.keys() if k in INTERCEPT_CAPABLE
        ]

        if len(possible_interceptors) <= 0:
            possible_interceptors = [
                k for k, v in self.aircraft_inventory.items()
                if k in CAP_CAPABLE and v >= 2
            ]

        if number_of_interceptor_groups > 0:
            inventory = dict({
                k: v
                for k, v in self.aircraft_inventory.items()
                if k in possible_interceptors
            })
            for i in range(number_of_interceptor_groups):
                try:
                    unit = random.choice(
                        [k for k, v in inventory.items() if v >= 2])
                except IndexError:
                    break
                inventory[unit] = inventory[unit] - 2
                flight = Flight(unit, 2, self.from_cp, FlightType.INTERCEPTION)
                flight.scheduled_in = 1
                flight.points = []

                self.interceptor_flights.append(flight)
                self.flights.append(flight)

            # Update inventory
            for k, v in inventory.items():
                self.aircraft_inventory[k] = v