Source code for logic.signal

import numpy as np
import glm




class Signal:
    """ The Signal class

    Provides methods for signal modeling
    """

    def __init__(self, departure_time: int, direction: 'glm.vec3',
                 speed: 'glm.vec3', power_multiply: int):
        self.direction: 'glm.vec3' = direction
        self.speed: 'glm.vec3' = speed
        self.power_multiply: int = power_multiply
        self.reflected: bool = False
        self.init_power: float = 150000 * 40 * 0.95

        # init power
        self.power: float = self.init_power

        self.reflection_depth: int = 3
        self.departure_time = departure_time



    def update(self, new_direction, new_speed, new_time: int):
        """
        Update signal if it collides with object
        :param new_direction: vector of new direction of signal
        :param new_speed: vector of new signal speed
        :param new_time: time when signal reflected
        """
        self.power = self.power / np.sum(self.position(new_time) ** 2)
        self.direction = new_direction
        self.speed = new_speed
        self.departure_time = new_time
        self.reflected += 1


    # reflect from earth


    def reflect(self, new_time: int):
        if self.check_depth():
            return

        if self.position(new_time).z < 0.01:
            self.power = self.power
        else:
            self.power = self.power / np.sum(self.position(new_time) ** 2)
        self.direction = self.position(new_time)
        self.reflected += 1
        self.departure_time = new_time


    # check if signal hit reflection depth


    def check_depth(self):
        return self.reflected == self.reflection_depth




    def position(self, time: int) -> 'glm.vec3':
        """
        Returns the position of the signal depending on the time.
        :param time: time in the simulation
        """
        if self.reflected % 2 == 1:
            return self.direction - self._position(time)
        return self.direction + self._position(time)


    def _position(self, time: int) -> 'glm.vec3':
        """
        Return the position based on speed (does not take
        into account the direction of the signal)

        :param time: time in the simulation
        :type time: int
        :return: vector of position
        :rtype: glm.vec3
        """
        return abs(time - self.departure_time) * self.speed