Source code for logic.collision_detector

import numpy as np

from logic.signal import Signal
from logic.radar import Radar
from objects.aircraft import Aircraft




class CollisionDetector:
    """ The collision detectors class

    Provides logic for calculating collisions of objects and signals
    """

    def __init__(self, radar: Radar):
        """ The CollisionDetector class initializer.

        :param radar: The radar object
        :type radar: Radar
        """
        self.radar: Radar = radar



    def scan_objects(self, signals: list[Signal], objects: list[Aircraft],
                     time: int) -> list[Signal]:
        """ A method that search for collision between objects and signals.

        :param signals: List of signals that will be checked
        :type signals: list[Signal]
        :param objects: List of objects that will be checked
        :type objects: list[Aircraft]
        :param time: Current time in the simulation
        :return: List of signals that collided with objects
        :rtype: list[Signal]
        """
        return_signals = set()
        for signal in signals:
            for obj in objects:
                if signal.position(time).z <= 0:
                    signal.reflect(time)

                if not signal.check_depth() and np.sqrt(np.sum((
                                                                       signal.position(
                                                                               time) - obj.position) ** 2)) < obj.reflection_radius:
                    signal.update(obj.position, -signal.speed, time + 2)
                    return_signals.add(signal)
                elif ((not signal.check_depth()) and
                      np.sqrt(np.sum((signal.position(time)) ** 2))
                      >= self.radar.emitter.range_of_action):
                    return_signals.add(signal)
        return list(return_signals)




    def scan_radar(self, signals: list[Signal], time: int) -> list[Signal]:
        """ A method that search for collision between radar and
        reflected signals

        :param signals: List of signals that will be checked
        :type signals: list[Signal]
        :param time: Current time in the simulation
        :type time: int
        :return: List of signals that collided with radar
        :rtype: list[Signal]
        """
        return list(filter(
            lambda x: x.reflected and np.sqrt(np.sum(
                (x.position(time) - self.radar.receiver.position) ** 2))
                      <= self.radar.receiver.radius, signals)
        )




    def scan_floor(self, signals: list[Signal], time):
        return_signals = []
        for signal in signals:
            if signal.position(time).z <= 0:
                signal.reflect(time)
        return return_signals