def __init__(
            self,
            gl_,  # global variables
            layer_=-4,  # layer where the shooting sprite will be display
            timing_=16,  # refreshing rate, default is 16ms (60 fps)
            surface_name_=''):

        self.layer = layer_

        pygame.sprite.Sprite.__init__(self, self.containers)

        # change sprite layer
        if isinstance(gl_.All, pygame.sprite.LayeredUpdates):
            gl_.All.change_layer(self, layer_)

        self.images_copy = ShootingStar.image.copy()
        self.image = self.images_copy[0] if isinstance(
            ShootingStar.image, list) else self.images_copy
        self.w, self.h = pygame.display.get_surface().get_size()
        self.position = pygame.math.Vector2(randint(0, self.w),
                                            randint(-self.h, 0))
        self.rect = self.image.get_rect(midbottom=self.position)
        self.speed = pygame.math.Vector2(uniform(-30, 30), 60)
        self.rotation = -270 - int(degrees(atan2(self.speed.y, self.speed.x)))
        self.image = pygame.transform.rotozoom(self.image, self.rotation, 1)
        self.blend = pygame.BLEND_RGB_ADD
        self.timing = timing_
        self.gl = gl_
        self.dt = 0
        self.surface_name = surface_name_
        self.id_ = id(self)
        self.shooting_star_object = Broadcast(self.make_object())

        Broadcast.add_object_id(self.id_)
    def __init__(self,
                 vector_: pygame.math.Vector2,       # background speed vector (pygame.math.Vector2)
                 position_: pygame.math.Vector2,          # original position (tuple)
                 gl_,                    # global variables  (GL class)
                 layer_: int = -8,       # layer used default is -8 (int <= 0)
                 blend_: int = 0,        # pygame blend effect (e.g pygame.BLEND_RGB_ADD, or int)
                 event_name_: str = '',  # event name (str)
                 timing_=0
                 ):

        self.layer = layer_

        pygame.sprite.Sprite.__init__(self, self.containers)

        # change sprite layer
        if isinstance(gl_.All, pygame.sprite.LayeredUpdates):
            gl_.All.change_layer(self, layer_)

        self.images_copy = Background.image.copy()
        self.image = self.images_copy[0] if isinstance(Background.image, list) else self.images_copy
        self.rect = self.image.get_rect(topleft=position_)
        self.position = position_
        self.vector = vector_
        self.gl = gl_
        self.blend = blend_
        self.event_name = event_name_
        self.id_ = id(self)
        self.rotation = 0
        self.timing = timing_
        self.dt = 0
        if self.event_name == 'STATION':
            self.rotation = 0
            self.background_object = Broadcast(self.make_rotation_object())
        else:
            self.background_object = Broadcast(self.make_object())
    def run(self):

        old_data = Broadcast.MessageQueue

        # todo self.gl.P1CS_STOP is for MirroredPlayer1Class what about MirroredPlayer2Class
        while not self.gl.P1CS_STOP and not self.gl.SPRITE_CLIENT_STOP:

            # check for the signal.
            # if signal is set, sending data to multi-players
            if self.gl.SIGNAL.isSet():

                self.gl.SIGNAL.clear()

                buffer_ = self.gl.BUFFER
                # todo check if data are different

                # Sort the data before sending them, DeleteSpriteCommand at the end with
                # Broadcast.live_object_inventory
                Broadcast.sort_message_queue()
                data = Broadcast.MessageQueue

                try:
                    if data is not None and len(data) > 0:
                        pickle_data = cpickle.dumps(data)
                        # The compress() function reads the input data and compresses it and returns a LZ4 frame.
                        # A frame consists of a header, and a sequence of blocks of compressed data, and a frame
                        # end marker (and optionally a checksum of the uncompressed data). The decompress() function
                        # takes a full LZ4 frame, decompresses it (and optionally verifies the uncompressed data
                        # against the stored checksum), and returns the uncompressed data.
                        compress_data = lz4.frame.compress(
                            pickle_data,
                            compression_level=lz4.frame.COMPRESSIONLEVEL_MAX)
                        # send the entire buffer bytes like data
                        self.sock.sendall(compress_data)

                        # todo counting total bytes sent
                        data_received = self.sock.recv(buffer_)
                        # print('\nFrame # %s , data sent %s, data received %s '
                        #      % (FRAME, len(compress_data), len(data_received)))
                        GL.BYTES_SENT.append(len(compress_data))
                        GL.BYTES_RECEIVED.append(len(data_received))

                        old_data = data

                except (socket.error, cpickle.UnpicklingError) as error:
                    print('\n[-]SpriteClient - ERROR @ frame: %s : %s %s' %
                          (self.gl.FRAME, error, time.ctime()))

            # 1ms delay will create large fps oscillation for
            # frame rate e.g 300fps. For 70 fps the fluctuating will be marginal
            pygame.time.wait(1)

        print("\n[+]SpriteClient - is now closed...")
        self.sock.close()
 def quit(self) -> None:
     Broadcast.remove_object_id(self.id_)
     obj = self.delete_object()
     broadcast_object = Broadcast(obj)
     broadcast_object.queue()
     self.kill()
     ...
    def __init__(self,
                 parent_,
                 pos_,
                 gl_,
                 timing_,
                 layer_,
                 texture_name_,
                 mute_=False):

        self.layer = layer_
        pygame.sprite.Sprite.__init__(self, self.containers)
        if isinstance(gl_.All, pygame.sprite.LayeredUpdates):
            if layer_:
                gl_.All.change_layer(self, layer_)

        self.images_copy = Explosion.images.copy()
        self.image = self.images_copy[0] if isinstance(
            self.images_copy, list) else self.images_copy
        self.timing = timing_
        self.length = len(self.images) - 1
        self.pos = pos_
        self.gl = gl_
        self.position = pygame.math.Vector2(*self.pos)
        self.rect = self.image.get_rect(center=self.pos)
        self.dt = 0
        self.blend = pygame.BLEND_RGB_ADD
        self.parent = parent_
        self.index = 0
        self.id_ = id(self)
        self.texture_name = texture_name_
        self.mute = mute_
        # Create the network object
        self.explosion_object = Broadcast(self.make_object())
        # Create sound object
        self.explosion_sound_object = Broadcast(
            self.make_sound_object('EXPLOSION_SOUND'))

        Broadcast.add_object_id(self.id_)
    def __init__(self, gl_, timing_, pos_, surface_name_, layer_=0):

        pygame.sprite.Sprite.__init__(self, self.containers)

        if isinstance(gl_.All, pygame.sprite.LayeredUpdates):
            if layer_:
                gl_.All.change_layer(self, layer_)

        self.image = Transport.image
        self.image_copy = self.image.copy()
        self.rect = self.image.get_rect(center=pos_)
        self.timing = timing_
        self.gl = gl_
        self.dt = 0
        self.fxdt = 0
        self.layer = layer_
        self.blend = 0
        self.previous_pos = pygame.math.Vector2()            # previous position
        self.max_life = 5000
        self.life = 5000                                     # MirroredTransportClass max hit points
        self.damage = 10000                                  # Damage transfer after collision
        self.mask = pygame.mask.from_surface(self.image)     # Image have to be convert_alpha compatible
        self.pos = pos_
        self.index = 0
        self.impact = False
        self.vertex_array = []
        self.engine = self.engine_on()
        self.surface_name = surface_name_
        self.id_ = id(self)
        self.transport_object = Broadcast(self.make_object())
        self.impact_sound_object = Broadcast(self.make_sound_object('IMPACT'))
        half = self.gl.SCREENRECT.w >> 1
        self.safe_zone = pygame.Rect(half - 200, half, 400, self.gl.SCREENRECT.bottom - half)
        self.half_life = (self.max_life >> 1)

        Broadcast.add_object_id(self.id_)   # this is now obsolete since it is done from main loop
Exemplo n.º 7
0
 def quit(self) -> None:
     Broadcast.remove_object_id(self.id_)
     obj = Broadcast(self.delete_object())
     obj.queue()
     self.kill()
class Background(pygame.sprite.Sprite):

    containers = None   # pygame group
    image = None        # surface to display (can be a list of Surface or a single pygame.Surface)

    def __init__(self,
                 vector_: pygame.math.Vector2,       # background speed vector (pygame.math.Vector2)
                 position_: pygame.math.Vector2,          # original position (tuple)
                 gl_,                    # global variables  (GL class)
                 layer_: int = -8,       # layer used default is -8 (int <= 0)
                 blend_: int = 0,        # pygame blend effect (e.g pygame.BLEND_RGB_ADD, or int)
                 event_name_: str = '',  # event name (str)
                 timing_=0
                 ):

        self.layer = layer_

        pygame.sprite.Sprite.__init__(self, self.containers)

        # change sprite layer
        if isinstance(gl_.All, pygame.sprite.LayeredUpdates):
            gl_.All.change_layer(self, layer_)

        self.images_copy = Background.image.copy()
        self.image = self.images_copy[0] if isinstance(Background.image, list) else self.images_copy
        self.rect = self.image.get_rect(topleft=position_)
        self.position = position_
        self.vector = vector_
        self.gl = gl_
        self.blend = blend_
        self.event_name = event_name_
        self.id_ = id(self)
        self.rotation = 0
        self.timing = timing_
        self.dt = 0
        if self.event_name == 'STATION':
            self.rotation = 0
            self.background_object = Broadcast(self.make_rotation_object())
        else:
            self.background_object = Broadcast(self.make_object())

    def make_object(self) -> StaticSprite:
        return StaticSprite(frame_=self.gl.FRAME, id_=self.id_, surface_=self.event_name,
                            layer_=self.layer, blend_=self.blend, rect_=self.rect)

    def make_rotation_object(self) -> RotateSprite:
        return RotateSprite(frame_=self.gl.FRAME, id_=self.id_, surface_=self.event_name,
                            layer_=self.layer, blend_=self.blend, rect_=self.rect, rotation_=self.rotation)

    def process(self):

        if self.event_name == 'CL1':
            self.rect.move_ip(self.vector)
            if self.rect.y > 1023:
                self.rect.y = randint(-1024, - CL1.get_height())
                self.rect.x = randint(-400, 400)
            self.background_object.update({'frame': self.gl.FRAME, 'rect': self.rect})
            self.background_object.queue()

        elif self.event_name == 'CL2':
            self.rect.move_ip(self.vector)
            if self.rect.y > 1023:
                self.rect.y = randint(-1024, - CL2.get_height())
                self.rect.x = randint(-400, 400)
            self.background_object.update({'frame': self.gl.FRAME, 'rect': self.rect})
            self.background_object.queue()

        elif self.event_name == 'BLUE_PLANET':
            self.rect.move_ip(self.vector)
            if self.rect.y > 1023:
                self.rect.y = randint(-1024, - BLUE_PLANET.get_height())
                self.rect.x = randint(-400, 400)
            self.background_object.update({'frame': self.gl.FRAME,
                                           'rect': self.rect})
            self.background_object.queue()

        elif self.event_name == 'STATION':
            # below 8192 frames the station is not on sight

            if self.gl.FRAME < 12280:
                self.rect.move_ip(self.vector)

            # no need to rotate station if not on sight
            if self.rect.colliderect(self.gl.SCREENRECT):
                centre = self.rect.center
                self.image = pygame.transform.rotate(self.images_copy.copy(), self.rotation)
                self.rect = self.image.get_rect(center=centre)
                self.background_object.update({'frame': self.gl.FRAME,
                                               'rect': self.rect,
                                               'rotation': self.rotation})
                self.background_object.queue()
                self.rotation += 0.2

        else:
            if self.event_name in ('BACK1_S', 'BACK2_S'):
                self.rect.move_ip(self.vector)
                if self.rect.y > 1023:
                    self.rect.y = -1024

                self.background_object.update({'frame': self.gl.FRAME, 'rect': self.rect})
                self.background_object.queue()

            elif self.event_name == 'BACK3':
                if self.gl.FRAME < 12288:
                    self.rect.move_ip(self.vector)

                # if self.gl.FRAME > 12288:
                #    self.rect.y = 0

                self.background_object.update({'frame': self.gl.FRAME, 'rect': self.rect})
                self.background_object.queue()

            # Any other background type
            else:
                self.rect.move_ip(self.vector)
                if self.rect.y > 1023:
                    self.rect.y = -1024
                    self.rect.x = 0
                self.background_object.update({'frame': self.gl.FRAME, 'rect': self.rect})
                self.background_object.queue()

    def update(self):

        if self.timing != 0:
            # update frequently
            if self.dt > self.timing:
                self.process()
                self.dt = 0
            else:
                self.dt += self.gl.TIME_PASSED_SECONDS

        # update every frames
        else:
            self.process()
class ShootingStar(pygame.sprite.Sprite):

    image = None  # sprite surface (single surface)
    containers = None  # sprite group to use

    def __init__(
            self,
            gl_,  # global variables
            layer_=-4,  # layer where the shooting sprite will be display
            timing_=16,  # refreshing rate, default is 16ms (60 fps)
            surface_name_=''):

        self.layer = layer_

        pygame.sprite.Sprite.__init__(self, self.containers)

        # change sprite layer
        if isinstance(gl_.All, pygame.sprite.LayeredUpdates):
            gl_.All.change_layer(self, layer_)

        self.images_copy = ShootingStar.image.copy()
        self.image = self.images_copy[0] if isinstance(
            ShootingStar.image, list) else self.images_copy
        self.w, self.h = pygame.display.get_surface().get_size()
        self.position = pygame.math.Vector2(randint(0, self.w),
                                            randint(-self.h, 0))
        self.rect = self.image.get_rect(midbottom=self.position)
        self.speed = pygame.math.Vector2(uniform(-30, 30), 60)
        self.rotation = -270 - int(degrees(atan2(self.speed.y, self.speed.x)))
        self.image = pygame.transform.rotozoom(self.image, self.rotation, 1)
        self.blend = pygame.BLEND_RGB_ADD
        self.timing = timing_
        self.gl = gl_
        self.dt = 0
        self.surface_name = surface_name_
        self.id_ = id(self)
        self.shooting_star_object = Broadcast(self.make_object())

        Broadcast.add_object_id(self.id_)

    def delete_object(self) -> DeleteSpriteCommand:
        """
        Send a command to kill an object on client side.

        :return: DetectCollisionSprite object
        """
        return DeleteSpriteCommand(frame_=self.gl.FRAME,
                                   to_delete_={self.id_: self.surface_name})

    def make_object(self) -> RotateSprite:
        return RotateSprite(frame_=self.gl.FRAME,
                            id_=self.id_,
                            surface_=self.surface_name,
                            layer_=self.layer,
                            blend_=self.blend,
                            rect_=self.rect,
                            rotation_=self.rotation)

    def quit(self) -> None:
        Broadcast.remove_object_id(self.id_)
        obj = Broadcast(self.delete_object())
        obj.queue()
        self.kill()

    def update(self):

        if self.dt > self.timing:

            if self.rect.centery > self.h:
                self.quit()
                return
            self.rect = self.image.get_rect(center=self.position)
            self.position += self.speed
            if self.rect.colliderect(self.gl.SCREENRECT):
                self.shooting_star_object.update({
                    'frame': self.gl.FRAME,
                    'rect': self.rect,
                    'rotation': self.rotation
                })
                self.shooting_star_object.queue()

            self.dt = 0

        else:
            self.dt += self.gl.TIME_PASSED_SECONDS
class Explosion(pygame.sprite.Sprite):
    images = None
    containers = None

    def __init__(self,
                 parent_,
                 pos_,
                 gl_,
                 timing_,
                 layer_,
                 texture_name_,
                 mute_=False):

        self.layer = layer_
        pygame.sprite.Sprite.__init__(self, self.containers)
        if isinstance(gl_.All, pygame.sprite.LayeredUpdates):
            if layer_:
                gl_.All.change_layer(self, layer_)

        self.images_copy = Explosion.images.copy()
        self.image = self.images_copy[0] if isinstance(
            self.images_copy, list) else self.images_copy
        self.timing = timing_
        self.length = len(self.images) - 1
        self.pos = pos_
        self.gl = gl_
        self.position = pygame.math.Vector2(*self.pos)
        self.rect = self.image.get_rect(center=self.pos)
        self.dt = 0
        self.blend = pygame.BLEND_RGB_ADD
        self.parent = parent_
        self.index = 0
        self.id_ = id(self)
        self.texture_name = texture_name_
        self.mute = mute_
        # Create the network object
        self.explosion_object = Broadcast(self.make_object())
        # Create sound object
        self.explosion_sound_object = Broadcast(
            self.make_sound_object('EXPLOSION_SOUND'))

        Broadcast.add_object_id(self.id_)

    def delete_object(self) -> DeleteSpriteCommand:
        """
        Send a command to kill an object on client side.

        :return: DetectCollisionSprite object
        """
        return DeleteSpriteCommand(frame_=self.gl.FRAME,
                                   to_delete_={self.id_: self.texture_name})

    def play_explosion_sound(self) -> None:
        """
        Play the sound explosion locally and forward the sound object to the client(s).

        :return: None
        """

        # play the sound locally
        self.gl.MIXER.play(sound_=EXPLOSION_SOUND,
                           loop_=False,
                           priority_=0,
                           volume_=1.0,
                           fade_out_ms=0,
                           panning_=True,
                           name_='EXPLOSION_SOUND',
                           x_=self.rect.centerx,
                           object_id_=id(EXPLOSION_SOUND),
                           screenrect_=self.gl.SCREENRECT)
        # Add the sound object to the queue
        self.explosion_sound_object.play()

    def make_sound_object(self, sound_name_: str) -> SoundAttr:
        """
        Create a network sound object

        :param sound_name_: string; represent the sound name e.g 'EXPLOSION_SOUND"
        :return: SoundAttr object
        """
        assert isinstance(sound_name_, str), \
            "Positional argument <sound_name_> is type %s , expecting string." % type(sound_name_)

        if sound_name_ not in globals():
            raise NameError('Sound %s is not define.' % sound_name_)

        return SoundAttr(frame_=self.gl.FRAME,
                         id_=self.id_,
                         sound_name_=sound_name_,
                         rect_=self.rect)

    def make_object(self) -> AnimatedSprite:
        return AnimatedSprite(frame_=self.gl.FRAME,
                              id_=self.id_,
                              surface_=self.texture_name,
                              layer_=self.layer,
                              blend_=self.blend,
                              rect_=self.rect,
                              index_=self.index)

    def quit(self) -> None:
        Broadcast.remove_object_id(self.id_)
        obj = Broadcast(self.delete_object())
        obj.queue()
        self.kill()

    def update(self):

        if self.dt > self.timing:

            if self.rect.colliderect(self.gl.SCREENRECT):

                if self.index == 0 and not self.mute:
                    self.play_explosion_sound()

                self.image = self.images_copy[self.index]
                self.rect = self.image.get_rect(center=self.rect.center)
                self.index += 1

                if self.index > self.length:
                    self.quit()
                    return

                self.dt = 0

                self.explosion_object.update({
                    'frame': self.gl.FRAME,
                    'rect': self.rect,
                    'index': self.index,
                    'blend': self.blend
                })
                self.explosion_object.queue()

            else:
                self.quit()
                return
        else:
            self.dt += self.gl.TIME_PASSED_SECONDS
    def __init__(self,
                 asteroid_name_: str,
                 pos_: tuple,
                 gl_: GL,
                 blend_: int = 0,
                 timing_: int = 16,
                 layer_: int = -2,
                 particles_: bool = True):
        """
        Create debris after asteroid explosion or collision

        :param asteroid_name_: string; Parent name (not used)
        :param pos_: tuple, representing the impact position (x, y)
        :param gl_: class GL, global constants
        :param blend_: integer; Sprite blend effect, must be > 0 or any of the following BLEND_RGBA_ADD,
        BLEND_RGBA_SUB, BLEND_RGBA_MULT, BLEND_RGBA_MIN, BLEND_RGBA_MAX BLEND_RGB_ADD,
        BLEND_RGB_SUB, BLEND_RGB_MULT, BLEND_RGB_MIN, BLEND_RGB_MAX
        :param timing_: integer; Sprite refreshing time in milliseconds, must be >=0
        :param layer_: integer; Sprite layer must be <=0 (0 is the top layer)
        :param particles_: bool; Particles effect after asteroid desintegration
        """

        assert isinstance(asteroid_name_, str), \
            "Positional argument <asteroid_name_> is type %s , expecting string." % type(asteroid_name_)
        assert isinstance(pos_, tuple), \
            "Positional argument <pos_> is type %s , expecting tuple." % type(pos_)
        assert isinstance(timing_, int), \
            "Positional argument <timing_> is type %s , expecting integer." % type(timing_)
        assert isinstance(blend_, int), \
            "Positional argument <blend_> is type %s , expecting integer." % type(blend_)
        assert isinstance(layer_, int), \
            "Positional argument <layer_> is type %s , expecting integer." % type(layer_)
        assert isinstance(particles_, bool), \
            "Positional argument <particles_> is type %s , expecting boolean." % type(particles_)

        if self.containers is None:
            raise ValueError(
                'Debris.containers is not initialised.\nMake sure to assign the containers to'
                ' a pygame group prior instantiation.\ne.g: Debris.containers = '
                'pygame.sprite.Group()')
        if self.image is None:
            raise ValueError(
                "Debris.image is not initialised.\nMake sure to assign a texture to "
                "prior instantiation.\ne.g: Debris.image = 'CHOOSE_YOUR_TEXTURE'"
            )

        if timing_ < 0:
            raise ValueError('Positional argument timing_ cannot be < 0')
        if blend_ < 0:
            raise ValueError('Positional argument blend_ cannot be < 0')
        if layer_ > 0:
            raise ValueError('Positional argument layer_ cannot be > 0')

        self.layer = layer_

        pygame.sprite.Sprite.__init__(self, self.containers)

        # change sprite layer
        if isinstance(gl_.All, pygame.sprite.LayeredUpdates):
            gl_.All.change_layer(self, layer_)

        self.image = Debris.image
        self.rect = self.image.get_rect(center=pos_)
        self.speed = pygame.math.Vector2(uniform(-10, +10), uniform(-8, +8))
        self.damage = randint(5, 15)
        self.timing = timing_
        self.dt = 0
        self.fxdt = 0
        self.gl = gl_
        self.asteroid_name = asteroid_name_  # not used
        self.blend = blend_
        self.layer = layer_

        self.life = self.damage
        self.points = self.life
        self.rotation = 0
        self.scale = 1.0
        self.id_ = id(self)
        self.asteroid_object = Broadcast(self.make_object())

        self.vertex_array = []

        # todo create instances in the vertex_array (declare in global)
        #  before instanciating debris.
        #  make a copy of the vertex_array and goes through the list changing arguments:
        #  position_, vector_. Assign the list to self.vertex_array
        if particles_:
            angle = math.radians(uniform(0, 359))
            self.asteroid_particles_fx(position_=pygame.math.Vector2(
                self.rect.center),
                                       vector_=pygame.math.Vector2(
                                           math.cos(angle) * randint(5, 10),
                                           math.sin(angle) * randint(5, 10)),
                                       images_=FIRE_PARTICLES.copy(),
                                       layer_=self.layer,
                                       blend_=pygame.BLEND_RGB_ADD)
        Broadcast.add_object_id(self.id_)
class Debris(pygame.sprite.Sprite):

    containers = None
    image = None

    def __init__(self,
                 asteroid_name_: str,
                 pos_: tuple,
                 gl_: GL,
                 blend_: int = 0,
                 timing_: int = 16,
                 layer_: int = -2,
                 particles_: bool = True):
        """
        Create debris after asteroid explosion or collision

        :param asteroid_name_: string; Parent name (not used)
        :param pos_: tuple, representing the impact position (x, y)
        :param gl_: class GL, global constants
        :param blend_: integer; Sprite blend effect, must be > 0 or any of the following BLEND_RGBA_ADD,
        BLEND_RGBA_SUB, BLEND_RGBA_MULT, BLEND_RGBA_MIN, BLEND_RGBA_MAX BLEND_RGB_ADD,
        BLEND_RGB_SUB, BLEND_RGB_MULT, BLEND_RGB_MIN, BLEND_RGB_MAX
        :param timing_: integer; Sprite refreshing time in milliseconds, must be >=0
        :param layer_: integer; Sprite layer must be <=0 (0 is the top layer)
        :param particles_: bool; Particles effect after asteroid desintegration
        """

        assert isinstance(asteroid_name_, str), \
            "Positional argument <asteroid_name_> is type %s , expecting string." % type(asteroid_name_)
        assert isinstance(pos_, tuple), \
            "Positional argument <pos_> is type %s , expecting tuple." % type(pos_)
        assert isinstance(timing_, int), \
            "Positional argument <timing_> is type %s , expecting integer." % type(timing_)
        assert isinstance(blend_, int), \
            "Positional argument <blend_> is type %s , expecting integer." % type(blend_)
        assert isinstance(layer_, int), \
            "Positional argument <layer_> is type %s , expecting integer." % type(layer_)
        assert isinstance(particles_, bool), \
            "Positional argument <particles_> is type %s , expecting boolean." % type(particles_)

        if self.containers is None:
            raise ValueError(
                'Debris.containers is not initialised.\nMake sure to assign the containers to'
                ' a pygame group prior instantiation.\ne.g: Debris.containers = '
                'pygame.sprite.Group()')
        if self.image is None:
            raise ValueError(
                "Debris.image is not initialised.\nMake sure to assign a texture to "
                "prior instantiation.\ne.g: Debris.image = 'CHOOSE_YOUR_TEXTURE'"
            )

        if timing_ < 0:
            raise ValueError('Positional argument timing_ cannot be < 0')
        if blend_ < 0:
            raise ValueError('Positional argument blend_ cannot be < 0')
        if layer_ > 0:
            raise ValueError('Positional argument layer_ cannot be > 0')

        self.layer = layer_

        pygame.sprite.Sprite.__init__(self, self.containers)

        # change sprite layer
        if isinstance(gl_.All, pygame.sprite.LayeredUpdates):
            gl_.All.change_layer(self, layer_)

        self.image = Debris.image
        self.rect = self.image.get_rect(center=pos_)
        self.speed = pygame.math.Vector2(uniform(-10, +10), uniform(-8, +8))
        self.damage = randint(5, 15)
        self.timing = timing_
        self.dt = 0
        self.fxdt = 0
        self.gl = gl_
        self.asteroid_name = asteroid_name_  # not used
        self.blend = blend_
        self.layer = layer_

        self.life = self.damage
        self.points = self.life
        self.rotation = 0
        self.scale = 1.0
        self.id_ = id(self)
        self.asteroid_object = Broadcast(self.make_object())

        self.vertex_array = []

        # todo create instances in the vertex_array (declare in global)
        #  before instanciating debris.
        #  make a copy of the vertex_array and goes through the list changing arguments:
        #  position_, vector_. Assign the list to self.vertex_array
        if particles_:
            angle = math.radians(uniform(0, 359))
            self.asteroid_particles_fx(position_=pygame.math.Vector2(
                self.rect.center),
                                       vector_=pygame.math.Vector2(
                                           math.cos(angle) * randint(5, 10),
                                           math.sin(angle) * randint(5, 10)),
                                       images_=FIRE_PARTICLES.copy(),
                                       layer_=self.layer,
                                       blend_=pygame.BLEND_RGB_ADD)
        Broadcast.add_object_id(self.id_)

    def delete_object(self) -> DeleteSpriteCommand:
        """
        Send a command to kill an object on client side.

        :return: DetectCollisionSprite object
        """
        return DeleteSpriteCommand(frame_=self.gl.FRAME,
                                   to_delete_={self.id_: self.asteroid_name})

    def make_object(self) -> DetectCollisionSprite:
        """
        Create a network sprite object.

        :return: DetectCollisionSprite object
        """
        return DetectCollisionSprite(frame_=self.gl.FRAME,
                                     id_=self.id_,
                                     surface_=self.asteroid_name,
                                     layer_=self.layer,
                                     blend_=self.blend,
                                     rect_=self.rect,
                                     rotation_=self.rotation,
                                     scale_=self.scale,
                                     damage_=self.damage,
                                     life_=self.life,
                                     points_=self.points)

    def remove_particle(self, p_) -> None:
        """
        Remove the sprite from the group it belongs to and remove
        the object from the vertex_array
        :param p_: pygame.sprite.Sprite
        :return: None
        """
        p_.kill()
        if p_ in self.vertex_array:
            self.vertex_array.remove(p_)

    def display_asteroid_particles_fx(self) -> None:
        # Display asteroid tail debris.
        if self.fxdt > self.timing - 8:  # 8 ms

            for p_ in self.vertex_array:

                p_.image = p_.images[p_.index %
                                     p_.length]  # load the next surface
                p_.rect.move_ip(p_.vector)  # Move the particle
                p_.vector *= 0.9999  # particle deceleration / attenuation
                rect_centre = p_.rect.center  # rect centre after deceleration

                next_image = p_.images[(p_.index + 1) %
                                       p_.length]  # Load the next image
                # Decrease image dimensions (re-scale)
                try:
                    particle_size = pygame.math.Vector2(
                        p_.w - p_.index * 4, p_.h - p_.index * 4)
                    # transform next image (re-scale)
                    p_.images[(p_.index + 1) % p_.length] = \
                        pygame.transform.scale(next_image, (int(particle_size.x), int(particle_size.y)))
                    # Redefine the rectangle after transformation to avoid a collapsing movement
                    # to the right
                    p_.rect = p_.images[(p_.index + 1) %
                                        p_.length].get_rect(center=rect_centre)

                    # delete the particle before exception
                    if particle_size.length() < 25:
                        self.remove_particle(p_)

                except (ValueError, IndexError):
                    self.remove_particle(p_)

                if not p_.rect.colliderect(
                        self.gl.SCREENRECT) or p_.vector.length() < 1:
                    self.remove_particle(p_)

                p_.index += 1
            self.fxdt = 0
        else:
            self.fxdt += self.gl.TIME_PASSED_SECONDS

    def asteroid_particles_fx(
        self,
        position_,  # particle starting location (tuple or pygame.math.Vector2)
        vector_,  # particle speed, pygame.math.Vector2
        images_,  # surface used for the particle, (list of pygame.Surface)
        layer_=0,  # Layer used to display the particles (int)
        blend_=pygame.BLEND_RGB_ADD  # Blend mode (int)
    ) -> None:
        """
        Create bright debris after explosion or asteroid collision
        """
        # Cap the number of particles to avoid lag
        # if len(self.gl.FIRE_PARTICLES_FX) > 100:
        #    return
        # Create fire particles when the aircraft is disintegrating
        sprite_ = pygame.sprite.Sprite()
        self.gl.All.add(sprite_)
        # self.gl.FIRE_PARTICLES_FX.add(sprite__)
        # assign the particle to a specific layer
        if isinstance(self.gl.All, pygame.sprite.LayeredUpdates):
            self.gl.All.change_layer(sprite_, layer_)
        sprite_.layer = layer_
        sprite_.blend = blend_  # use the additive mode
        sprite_.images = images_
        sprite_.image = images_[0]
        sprite_.rect = sprite_.image.get_rect(center=position_)
        sprite_.vector = vector_  # vector
        sprite_.w, sprite_.h = sprite_.image.get_size()
        sprite_.index = 0
        sprite_.length = len(sprite_.images) - 1
        # assign update method to self.display_fire_particle_fx
        # (local method to display the particles)
        sprite_.update = self.display_asteroid_particles_fx
        self.vertex_array.append(sprite_)

    def collide(self, player_=None, damage_: int = 0) -> None:
        """

        :return:
        """
        self.quit()
        ...

    def hit(self, player_=None, damage_: int = 0) -> None:
        """
        Check asteroid life after laser collision.

        :param player_: Player instance
        :param damage_: integer; Damage received
        :return: None
        """
        self.quit()
        ...

    def quit(self) -> None:
        Broadcast.remove_object_id(self.id_)
        obj = self.delete_object()
        broadcast_object = Broadcast(obj)
        broadcast_object.queue()
        self.kill()
        ...

    def update(self) -> None:
        """
        Update debris sprite
        :return:
        """
        # Inside the 60FPS Area
        if self.dt > self.timing:

            if self.rect.colliderect(self.gl.SCREENRECT):
                self.rect.move_ip(self.speed)
            else:
                self.quit()
                return

            self.asteroid_object.update({
                'frame': self.gl.FRAME,
                'id_': self.id_,
                'rect': self.rect,
                'life': self.life
            })
            self.asteroid_object.queue()
            self.dt = 0
        else:
            self.dt += self.gl.TIME_PASSED_SECONDS
    def __init__(self,
                 asteroid_name_: str,
                 gl_,
                 blend_: int = 0,
                 rotation_: int = 0,
                 scale_: int = 1,
                 timing_: int = 8,
                 layer_: int = 0):
        """

        :param asteroid_name_: strings, MirroredAsteroidClass name
        :param gl_: class GL (contains all the game constant)
        :param blend_: integer, Sprite blend effect, must be > 0
        :param rotation_: integer, Object rotation in degrees
        :param scale_: integer, Object scale value, default 1 -> no transformation. must be > 0
        :param timing_: integer; Refreshing time in milliseconds, must be > 0
        :param layer_: integer; Layer used. must be <= 0 (0 is the top layer)
        """
        """
        assert isinstance(asteroid_name_, str), \
            "Positional argument <asteroid_name_> is type %s , expecting string." % type(asteroid_name_)
        assert isinstance(blend_, int), \
            "Positional argument <blend_> is type %s , expecting integer." % type(blend_)
        if blend_ < 0:
            raise ValueError('Positional attribute blend_ must be > 0')
        assert isinstance(rotation_, (float, int)), \
            "Positional argument <rotation_> is type %s , expecting float or integer." % type(rotation_)
        assert isinstance(scale_, (float, int)), \
            "Positional argument <scale_> is type %s , expecting float or integer." % type(scale_)
        if scale_ < 0:
            raise ValueError('Positional attribute scale_ must be > 0')
        assert isinstance(timing_, int), \
            "Positional argument <timing_> is type %s , expecting integer." % type(timing_)
        if timing_ < 0:
            raise ValueError('Positional attribute timing_ must be >= 0')

        assert isinstance(layer_, int), \
            "Positional argument <layer_> is type %s , expecting integer." % type(layer_)
        if layer_ > 0:
            raise ValueError('Positional attribute layer_ must be <= 0')
        """
        self.layer = layer_

        pygame.sprite.Sprite.__init__(self, self.containers)

        # change sprite layer
        if isinstance(gl_.All, pygame.sprite.LayeredUpdates):
            gl_.All.change_layer(self, layer_)

        self.images_copy = Asteroid.image.copy()
        self.image = self.images_copy[0] if isinstance(
            Asteroid.image, list) else self.images_copy
        self.w, self.h = pygame.display.get_surface().get_size()

        self.appearance_frame = 0  # randint(100, 100240)  # When the asteroid start moving

        if asteroid_name_ == 'MAJOR_ASTEROID':
            self.speed = pygame.math.Vector2(0, 1)
            self.rect = self.image.get_rect(center=((self.w >> 1),
                                                    -self.image.get_height()))
            # MirroredAsteroidClass life points (proportional to its size)
            self.life = 5000
            self.damage = self.life * 2
        else:

            self.rect = self.image.get_rect(center=(randint(0, self.w),
                                                    -randint(0, self.h) -
                                                    self.image.get_height()))
            # self.rect = self.image.get_rect(center=(self.w // 2, - self.image.get_height()))

            self.speed = pygame.math.Vector2(0, uniform(
                +4, +8))  # * round(self.appearance_frame / 4000))

            if self.speed.length() == 0:
                self.speed = pygame.math.Vector2(0, 1)

            # MirroredAsteroidClass life points (proportional to its size)
            self.life = randint(self.rect.w,
                                max(self.rect.w, (self.rect.w >> 1) * 10))
            # Collision damage, how much life point
            # will be removed from players and transport in case of collision
            self.damage = self.life >> 1

        self.timing = timing_
        self.rotation = rotation_
        self.scale = scale_
        self.dt = 0
        self.gl = gl_
        self.asteroid_name = asteroid_name_
        self.blend = blend_
        # No need to pre-calculate the mask as all asteroid instanciation is
        # done before the main loop
        self.mask = pygame.mask.from_surface(self.image)

        # MirroredAsteroidClass value in case of destruction.
        self.points = self.life

        self.layer = layer_
        self.index = 0
        self.has_been_hit = False
        self.id_ = id(self)
        self.asteroid_object = Broadcast(self.make_object())
        self.impact_sound_object = Broadcast(self.make_sound_object('IMPACT'))

        Broadcast.add_object_id(self.id_)
class Asteroid(pygame.sprite.Sprite):

    containers = None
    image = None

    def __init__(self,
                 asteroid_name_: str,
                 gl_,
                 blend_: int = 0,
                 rotation_: int = 0,
                 scale_: int = 1,
                 timing_: int = 8,
                 layer_: int = 0):
        """

        :param asteroid_name_: strings, MirroredAsteroidClass name
        :param gl_: class GL (contains all the game constant)
        :param blend_: integer, Sprite blend effect, must be > 0
        :param rotation_: integer, Object rotation in degrees
        :param scale_: integer, Object scale value, default 1 -> no transformation. must be > 0
        :param timing_: integer; Refreshing time in milliseconds, must be > 0
        :param layer_: integer; Layer used. must be <= 0 (0 is the top layer)
        """
        """
        assert isinstance(asteroid_name_, str), \
            "Positional argument <asteroid_name_> is type %s , expecting string." % type(asteroid_name_)
        assert isinstance(blend_, int), \
            "Positional argument <blend_> is type %s , expecting integer." % type(blend_)
        if blend_ < 0:
            raise ValueError('Positional attribute blend_ must be > 0')
        assert isinstance(rotation_, (float, int)), \
            "Positional argument <rotation_> is type %s , expecting float or integer." % type(rotation_)
        assert isinstance(scale_, (float, int)), \
            "Positional argument <scale_> is type %s , expecting float or integer." % type(scale_)
        if scale_ < 0:
            raise ValueError('Positional attribute scale_ must be > 0')
        assert isinstance(timing_, int), \
            "Positional argument <timing_> is type %s , expecting integer." % type(timing_)
        if timing_ < 0:
            raise ValueError('Positional attribute timing_ must be >= 0')

        assert isinstance(layer_, int), \
            "Positional argument <layer_> is type %s , expecting integer." % type(layer_)
        if layer_ > 0:
            raise ValueError('Positional attribute layer_ must be <= 0')
        """
        self.layer = layer_

        pygame.sprite.Sprite.__init__(self, self.containers)

        # change sprite layer
        if isinstance(gl_.All, pygame.sprite.LayeredUpdates):
            gl_.All.change_layer(self, layer_)

        self.images_copy = Asteroid.image.copy()
        self.image = self.images_copy[0] if isinstance(
            Asteroid.image, list) else self.images_copy
        self.w, self.h = pygame.display.get_surface().get_size()

        self.appearance_frame = 0  # randint(100, 100240)  # When the asteroid start moving

        if asteroid_name_ == 'MAJOR_ASTEROID':
            self.speed = pygame.math.Vector2(0, 1)
            self.rect = self.image.get_rect(center=((self.w >> 1),
                                                    -self.image.get_height()))
            # MirroredAsteroidClass life points (proportional to its size)
            self.life = 5000
            self.damage = self.life * 2
        else:

            self.rect = self.image.get_rect(center=(randint(0, self.w),
                                                    -randint(0, self.h) -
                                                    self.image.get_height()))
            # self.rect = self.image.get_rect(center=(self.w // 2, - self.image.get_height()))

            self.speed = pygame.math.Vector2(0, uniform(
                +4, +8))  # * round(self.appearance_frame / 4000))

            if self.speed.length() == 0:
                self.speed = pygame.math.Vector2(0, 1)

            # MirroredAsteroidClass life points (proportional to its size)
            self.life = randint(self.rect.w,
                                max(self.rect.w, (self.rect.w >> 1) * 10))
            # Collision damage, how much life point
            # will be removed from players and transport in case of collision
            self.damage = self.life >> 1

        self.timing = timing_
        self.rotation = rotation_
        self.scale = scale_
        self.dt = 0
        self.gl = gl_
        self.asteroid_name = asteroid_name_
        self.blend = blend_
        # No need to pre-calculate the mask as all asteroid instanciation is
        # done before the main loop
        self.mask = pygame.mask.from_surface(self.image)

        # MirroredAsteroidClass value in case of destruction.
        self.points = self.life

        self.layer = layer_
        self.index = 0
        self.has_been_hit = False
        self.id_ = id(self)
        self.asteroid_object = Broadcast(self.make_object())
        self.impact_sound_object = Broadcast(self.make_sound_object('IMPACT'))

        Broadcast.add_object_id(self.id_)

    def delete_object(self) -> DeleteSpriteCommand:
        """
        Send a command to kill an object on client side.

        :return: DetectCollisionSprite object
        """
        return DeleteSpriteCommand(frame_=self.gl.FRAME,
                                   to_delete_={self.id_: self.asteroid_name})

    def make_sound_object(self, sound_name_: str) -> SoundAttr:
        """
        Create a network sound object

        :param sound_name_: string; represent the sound name e.g 'EXPLOSION_SOUND"
        :return: SoundAttr object
        """
        assert isinstance(sound_name_, str), \
            "Positional argument <sound_name_> is type %s , expecting string." % type(sound_name_)

        if sound_name_ not in globals():
            raise NameError('Sound %s is not define.' % sound_name_)

        return SoundAttr(frame_=self.gl.FRAME,
                         id_=self.id_,
                         sound_name_=sound_name_,
                         rect_=self.rect)

    def make_object(self) -> DetectCollisionSprite:
        """
        Create a network sprite object

        :return: DetectCollisionSprite object
        """
        return DetectCollisionSprite(frame_=self.gl.FRAME,
                                     id_=self.id_,
                                     surface_=self.asteroid_name,
                                     layer_=self.layer,
                                     blend_=self.blend,
                                     rect_=self.rect,
                                     rotation_=self.rotation,
                                     scale_=self.scale,
                                     damage_=self.damage,
                                     life_=self.life,
                                     points_=self.points)

    def create_gems(self, player_) -> None:
        """
        Create collectable gems after asteroid disintegration.
        :param player_: player causing asteroid explosion
        :return: None
        """
        if player_ is None:
            raise ValueError("Argument player_ cannot be none!.")
        if hasattr(player_, 'alive'):
            if player_.alive():
                number = randint(3, 15)
                for _ in range(number):
                    if _ < number:
                        MakeGems.inventory = set()
                    MakeGems(gl_=self.gl,
                             player_=player_,
                             object_=self,
                             ratio_=1.0,
                             timing_=8,
                             offset_=pygame.Rect(self.rect.centerx,
                                                 self.rect.centery,
                                                 randint(-100, 100),
                                                 randint(-100, 20)))

    def make_debris(self) -> None:
        """
        Create sprite debris (different sizes 32x32, 64x64 pixels)
        :return:None
        """

        if not globals().__contains__('MULT_ASTEROID_64'):
            raise NameError(
                "Texture MULT_ASTEROID_64 is missing!"
                "\nCheck file Texture.py for MULT_ASTEROID_64 assigment. ")

        if not globals().__contains__('MULT_ASTEROID_32'):
            raise NameError(
                "Texture MULT_ASTEROID_32 is missing!"
                "\nCheck file Texture.py for MULT_ASTEROID_32 assigment. ")

        size_x, size_y = self.image.get_size()

        if size_x > 128:
            aster = MULT_ASTEROID_64
            name = 'MULT_ASTEROID_64'

        else:
            aster = MULT_ASTEROID_32
            name = 'MULT_ASTEROID_32'

        length = len(aster) - 1
        if self.asteroid_name != 'MAJOR_ASTEROID':
            Debris.containers = self.gl.All, self.gl.ASTEROID
            for _ in range(8 if size_x > 255 else 6):
                element = randint(0, length)
                Debris.image = aster[element]
                Debris(asteroid_name_=name + '[' + str(element) + ']',
                       pos_=self.rect.center,
                       gl_=self.gl,
                       blend_=0,
                       timing_=16,
                       layer_=-2,
                       particles_=True)
        else:
            Debris.containers = self.gl.All, self.gl.ASTEROID
            aster = MULT_ASTEROID_64
            name = 'MULT_ASTEROID_64'
            length = len(aster) - 1
            for _ in range(10):
                element = randint(0, length)
                Debris.image = aster[element]
                Debris(asteroid_name_=name + '[' + str(element) + ']',
                       pos_=(self.rect.centerx + randint(-size_x, size_y),
                             self.rect.centery + randint(-size_x, size_y)),
                       gl_=self.gl,
                       blend_=0,
                       timing_=20,
                       layer_=randint(-2, 0),
                       particles_=False)

            aster = MULT_ASTEROID_32
            name = 'MULT_ASTEROID_32'
            length = len(aster) - 1
            for _ in range(10):
                element = randint(0, length)
                Debris.image = aster[element]
                Debris(asteroid_name_=name + '[' + str(element) + ']',
                       pos_=(self.rect.centerx + randint(-size_x, size_y),
                             self.rect.centery + randint(-size_x, size_y)),
                       gl_=self.gl,
                       blend_=0,
                       timing_=8,
                       layer_=randint(-2, 0),
                       particles_=False)

    def explode(self, player_) -> None:
        """
        Create an explosion sprite when asteroid life points < 1
        :param player_: Player causing asteroid explosion
        :return: None
        """

        if not globals().__contains__('EXPLOSION1'):
            raise NameError(
                "Texture EXPLOSION1 is missing!"
                "\nCheck file Texture.py for EXPLOSION1 assigment. ")
        # Create queue sprite
        Explosion.images = EXPLOSION1
        Explosion(self,
                  self.rect.center,
                  self.gl,
                  8,
                  0,
                  texture_name_='EXPLOSION1')  # self.layer)

        if not globals().__contains__('HALO_SPRITE12'):
            raise NameError(
                "Texture HALO_SPRITE12 is missing!"
                "\nCheck file Texture.py for HALO_SPRITE12 assigment. ")

        if not globals().__contains__('HALO_SPRITE14'):
            raise NameError(
                "Texture HALO_SPRITE14 is missing!"
                "\nCheck file Texture.py for HALO_SPRITE14 assigment. ")

        # Create Halo sprite
        AsteroidHalo.images = choice([HALO_SPRITE12, HALO_SPRITE14])
        AsteroidHalo.containers = self.gl.All
        AsteroidHalo(texture_name_='HALO_SPRITE12' if
                     AsteroidHalo.images is HALO_SPRITE12 else 'HALO_SPRITE14',
                     object_=self,
                     timing_=8)

        self.make_debris()
        if player_ is not None:
            self.create_gems(player_)
        self.quit()

    def hit(self, player_=None, damage_: int = 0) -> None:
        """
        Check asteroid life after laser collision.

        :param player_: Player instance
        :param damage_: integer; Damage received
        :return: None
        """
        assert isinstance(damage_, int), \
            "Positional argument <damage_> is type %s , expecting integer." % type(damage_)
        if damage_ < 0:
            raise ValueError('positional argument damage_ cannot be < 0')

        self.life -= damage_
        self.has_been_hit = True if self.asteroid_name != 'MAJOR_ASTEROID' else False

        if self.life < 1:
            if player_ is not None:
                if hasattr(player_, 'update_score'):
                    player_.update_score(self.points)
            self.explode(player_)

    def collide(self, player_=None, damage_: int = 0) -> None:
        """
        Check asteroid life after collision with players or transport

        :param player_: Player instance or transport
        :param damage_: integer; Damage received
        :return: None
        """
        assert isinstance(damage_, int), \
            "Positional argument <damage_> is type %s , expecting integer." % type(damage_)
        if damage_ < 0:
            raise ValueError('positional argument damage_ cannot be < 0')

        if not globals().__contains__('IMPACT1'):
            raise NameError("Sound IMPACT1 is missing!"
                            "\nCheck file Sounds.py for IMPACT1 assigment. ")
        if hasattr(self, 'life'):
            self.life -= damage_  # transfer damage to the asteroid (decrease life)
        else:
            raise AttributeError('self %s, %s does not have attribute life ' %
                                 (self, type(self)))

        # play asteroid burst sound locally
        self.gl.MIXER.play(sound_=IMPACT1,
                           loop_=False,
                           priority_=0,
                           volume_=1.0,
                           fade_out_ms=0,
                           panning_=True,
                           name_='IMPACT1',
                           x_=self.rect.centerx,
                           object_id_=id(IMPACT1),
                           screenrect_=self.gl.SCREENRECT)

        # broadcast asteroid burst sound
        self.impact_sound_object.play()

        # check if asteroid life is still > 0
        if self.life < 1:

            # check who is colliding with the asteroid
            # if not colliding with transport, transfer score to player.
            if not type(player_).__name__ == 'Transport':
                if player_ is not None:
                    # player has collide with asteroid, player1 or player 2 get the points
                    player_.update_score(self.points)
            else:
                # Transport does not get points
                ...
            # Split asteroid
            self.make_debris()
            self.quit()
        ...

    def quit(self) -> None:
        Broadcast.remove_object_id(self.id_)
        obj = Broadcast(self.delete_object())
        obj.queue()
        self.kill()

    def update(self) -> None:
        """
        Update asteroid sprites.

        :return: None
        """

        if self.gl.FRAME > self.appearance_frame:

            # start to move asteroid when frame number is over
            # self.appearance_frame (random frame number)
            self.rect.move_ip(self.speed)

            # asteroid is moving but not visible yet?
            # The rectangle bottom edge must be > 0 to start the code below
            if self.rect.midbottom[1] > 0:

                # Inside the 60 FPS Area
                if self.dt > self.timing:

                    # self.image = self.images_copy.copy()
                    if self.has_been_hit:
                        if not globals().__contains__('LAVA'):
                            raise NameError("Texture LAVA not available")
                        self.image.blit(LAVA[self.index % len(LAVA) - 1],
                                        (0, 0),
                                        special_flags=pygame.BLEND_RGB_ADD)
                        self.index += 1
                        self.has_been_hit = False

                    # if self.rotation != 0:
                    #    self.mask = pygame.mask.from_surface(self.image)

                    self.asteroid_object.update({
                        'frame': self.gl.FRAME,
                        'rect': self.rect,
                        'life': self.life
                    })
                    self.asteroid_object.queue()

                    self.dt = 0

                else:
                    self.dt += self.gl.TIME_PASSED_SECONDS

            if self.rect.midtop[1] > self.gl.SCREENRECT.h:
                self.quit()
Exemplo n.º 15
0
class AfterBurner(pygame.sprite.Sprite):

    containers = None
    images = None

    def __init__(self,
                 parent_,
                 gl_,
                 offset_: tuple,
                 timing_: int = 8,
                 blend_: int = 0,
                 layer_: int = 0,
                 texture_name_='EXHAUST'):
        """
        Create an exhaust effect for the player's

        :param parent_: Player's instance (MirroredPlayer1Class or MirroredPlayer2Class)
        :param gl_: Class GL (contains all the game constants
        :param offset_: tuple, offset location of the afterburner sprite (offset from the center)
        :param timing_: integer; Sprite refreshing time must be > 0
        :param blend_: integer; Sprite blending effect, must be > 0 or any of the following BLEND_RGBA_ADD,
        BLEND_RGBA_SUB, BLEND_RGBA_MULT, BLEND_RGBA_MIN, BLEND_RGBA_MAX BLEND_RGB_ADD,
        BLEND_RGB_SUB, BLEND_RGB_MULT, BLEND_RGB_MIN, BLEND_RGB_MAX
        :param layer_: integer; must be <= 0 (0 is the top layer)
        :param texture_name_: string corresponding to the texture used.
        """

        if parent_ is None:
            raise ValueError('Positional argument <parent_> cannot be None.')
        if gl_ is None:
            raise ValueError('Positional argument <gl_> cannot be None.')
        if offset_ is None:
            raise ValueError('Positional argument <offset_> cannot be None.')

        assert isinstance(offset_, tuple), \
            "Positional argument <offset_> is type %s , expecting tuple." % type(offset_)
        assert isinstance(timing_, int), \
            "Positional argument <timing_> is type %s , expecting integer." % type(timing_)
        assert isinstance(blend_, int), \
            "Positional argument <blend_> is type %s , expecting integer." % type(blend_)
        assert isinstance(layer_, int), \
            "Positional argument <layer_> is type %s , expecting integer." % type(layer_)
        assert isinstance(texture_name_, str), \
            "Positional argument <texture_name_> is type %s , expecting str." % type(texture_name_)

        if self.containers is None:
            raise ValueError(
                'AfterBurner.containers is not initialised.\nMake sure to assign the containers to'
                ' a pygame group prior instantiation.\ne.g: AfterBurner.containers = '
                'pygame.sprite.Group()')
        if self.images is None:
            raise ValueError(
                "AfterBurner.images is not initialised.\nMake sure to assign a texture to "
                "prior instantiation.\ne.g: AfterBurner.images = 'EXHAUST'")

        if timing_ < 0:
            raise ValueError('Positional argument timing_ cannot be < 0')

        self.layer = layer_
        pygame.sprite.Sprite.__init__(self, self.containers)

        if isinstance(gl_.All, pygame.sprite.LayeredUpdates):
            if layer_:
                gl_.All.change_layer(self, layer_)

        self.images = AfterBurner.images
        self.image = self.images[0] if isinstance(self.images,
                                                  list) else self.images
        self.parent = parent_
        self.offset = offset_
        x, y = self.parent.rect.centerx + self.offset[
            0], self.parent.rect.centery + self.offset[1]
        self.rect = self.image.get_rect(center=(x, y))
        self.timing = timing_
        self.dt = 0
        self.index = 0
        self.gl = gl_
        self.blend = blend_
        self.texture_name = texture_name_
        self.id_ = id(self)
        self.afterburner_object = Broadcast(self.make_object())

        Broadcast.add_object_id(self.id_)

    def delete_object(self) -> DeleteSpriteCommand:
        """
        Send a command to kill an object on client side.

        :return: DetectCollisionSprite object
        """
        return DeleteSpriteCommand(frame_=self.gl.FRAME,
                                   to_delete_={self.id_: self.texture_name})

    def make_object(self) -> AnimatedSprite:
        """
        Create a network object (AnimatedSprite)
        :return: AnimatedSprite
        """
        return AnimatedSprite(frame_=self.gl.FRAME,
                              id_=self.id_,
                              surface_=self.texture_name,
                              layer_=self.layer,
                              blend_=self.blend,
                              rect_=self.rect,
                              index_=self.index)

    def quit(self) -> None:
        Broadcast.remove_object_id(self.id_)
        obj = Broadcast(self.delete_object())
        obj.queue()
        self.kill()

    def update(self) -> None:
        """
        Update the sprite.

        :return: None
        """
        if self.dt > self.timing:

            # checking if MirroredPlayer1Class is still alive
            if self.parent.alive():

                # display animation if self.images is a list.
                if isinstance(self.images, list):
                    self.image = self.images[self.index % len(self.images) - 1]

                x, y = self.parent.rect.centerx + self.offset[
                    0], self.parent.rect.centery + self.offset[1]
                self.rect.center = (x, y)

                if self.rect.colliderect(self.gl.SCREENRECT):
                    self.afterburner_object.update({
                        'frame': self.gl.FRAME,
                        'rect': self.rect,
                        'index': self.index
                    })
                    self.afterburner_object.queue()

                self.dt = 0
                self.index += 1
            else:
                self.quit()
                return
        else:
            self.dt += self.gl.TIME_PASSED_SECONDS
Exemplo n.º 16
0
    def __init__(self,
                 parent_,
                 gl_,
                 offset_: tuple,
                 timing_: int = 8,
                 blend_: int = 0,
                 layer_: int = 0,
                 texture_name_='EXHAUST'):
        """
        Create an exhaust effect for the player's

        :param parent_: Player's instance (MirroredPlayer1Class or MirroredPlayer2Class)
        :param gl_: Class GL (contains all the game constants
        :param offset_: tuple, offset location of the afterburner sprite (offset from the center)
        :param timing_: integer; Sprite refreshing time must be > 0
        :param blend_: integer; Sprite blending effect, must be > 0 or any of the following BLEND_RGBA_ADD,
        BLEND_RGBA_SUB, BLEND_RGBA_MULT, BLEND_RGBA_MIN, BLEND_RGBA_MAX BLEND_RGB_ADD,
        BLEND_RGB_SUB, BLEND_RGB_MULT, BLEND_RGB_MIN, BLEND_RGB_MAX
        :param layer_: integer; must be <= 0 (0 is the top layer)
        :param texture_name_: string corresponding to the texture used.
        """

        if parent_ is None:
            raise ValueError('Positional argument <parent_> cannot be None.')
        if gl_ is None:
            raise ValueError('Positional argument <gl_> cannot be None.')
        if offset_ is None:
            raise ValueError('Positional argument <offset_> cannot be None.')

        assert isinstance(offset_, tuple), \
            "Positional argument <offset_> is type %s , expecting tuple." % type(offset_)
        assert isinstance(timing_, int), \
            "Positional argument <timing_> is type %s , expecting integer." % type(timing_)
        assert isinstance(blend_, int), \
            "Positional argument <blend_> is type %s , expecting integer." % type(blend_)
        assert isinstance(layer_, int), \
            "Positional argument <layer_> is type %s , expecting integer." % type(layer_)
        assert isinstance(texture_name_, str), \
            "Positional argument <texture_name_> is type %s , expecting str." % type(texture_name_)

        if self.containers is None:
            raise ValueError(
                'AfterBurner.containers is not initialised.\nMake sure to assign the containers to'
                ' a pygame group prior instantiation.\ne.g: AfterBurner.containers = '
                'pygame.sprite.Group()')
        if self.images is None:
            raise ValueError(
                "AfterBurner.images is not initialised.\nMake sure to assign a texture to "
                "prior instantiation.\ne.g: AfterBurner.images = 'EXHAUST'")

        if timing_ < 0:
            raise ValueError('Positional argument timing_ cannot be < 0')

        self.layer = layer_
        pygame.sprite.Sprite.__init__(self, self.containers)

        if isinstance(gl_.All, pygame.sprite.LayeredUpdates):
            if layer_:
                gl_.All.change_layer(self, layer_)

        self.images = AfterBurner.images
        self.image = self.images[0] if isinstance(self.images,
                                                  list) else self.images
        self.parent = parent_
        self.offset = offset_
        x, y = self.parent.rect.centerx + self.offset[
            0], self.parent.rect.centery + self.offset[1]
        self.rect = self.image.get_rect(center=(x, y))
        self.timing = timing_
        self.dt = 0
        self.index = 0
        self.gl = gl_
        self.blend = blend_
        self.texture_name = texture_name_
        self.id_ = id(self)
        self.afterburner_object = Broadcast(self.make_object())

        Broadcast.add_object_id(self.id_)
class Transport(pygame.sprite.Sprite):
    containers = None
    image = None

    def __init__(self, gl_, timing_, pos_, surface_name_, layer_=0):

        pygame.sprite.Sprite.__init__(self, self.containers)

        if isinstance(gl_.All, pygame.sprite.LayeredUpdates):
            if layer_:
                gl_.All.change_layer(self, layer_)

        self.image = Transport.image
        self.image_copy = self.image.copy()
        self.rect = self.image.get_rect(center=pos_)
        self.timing = timing_
        self.gl = gl_
        self.dt = 0
        self.fxdt = 0
        self.layer = layer_
        self.blend = 0
        self.previous_pos = pygame.math.Vector2()            # previous position
        self.max_life = 5000
        self.life = 5000                                     # MirroredTransportClass max hit points
        self.damage = 10000                                  # Damage transfer after collision
        self.mask = pygame.mask.from_surface(self.image)     # Image have to be convert_alpha compatible
        self.pos = pos_
        self.index = 0
        self.impact = False
        self.vertex_array = []
        self.engine = self.engine_on()
        self.surface_name = surface_name_
        self.id_ = id(self)
        self.transport_object = Broadcast(self.make_object())
        self.impact_sound_object = Broadcast(self.make_sound_object('IMPACT'))
        half = self.gl.SCREENRECT.w >> 1
        self.safe_zone = pygame.Rect(half - 200, half, 400, self.gl.SCREENRECT.bottom - half)
        self.half_life = (self.max_life >> 1)

        Broadcast.add_object_id(self.id_)   # this is now obsolete since it is done from main loop

    def delete_object(self) -> DeleteSpriteCommand:
        """
        Send a command to kill an object on client side.

        :return: DetectCollisionSprite object
        """
        return DeleteSpriteCommand(frame_=self.gl.FRAME, to_delete_={self.id_: self.surface_name})

    def make_sound_object(self, sound_name_: str) -> SoundAttr:
        return SoundAttr(frame_=self.gl.FRAME, id_=self.id_, sound_name_=sound_name_, rect_=self.rect)
    
    def make_object(self) -> StaticSprite:
        return StaticSprite(frame_=self.gl.FRAME, id_=self.id_, surface_=self.surface_name,
                            layer_=self.layer, blend_=self.blend, rect_=self.rect,
                            damage=self.damage, life=self.life, impact=self.impact)

    def engine_on(self) -> AfterBurner:
        AfterBurner.images = EXHAUST2
        calc_pos = (self.pos[0] - 400, self.pos[1] - 205)   # Top left corner position
        return AfterBurner(self, self.gl,
                           calc_pos, 8, pygame.BLEND_RGB_ADD,
                           self.layer - 1, texture_name_='EXHAUST2')

    def player_lost(self) -> None:
        PlayerLost.containers = self.gl.All
        PlayerLost.DIALOGBOX_READOUT_RED = DIALOGBOX_READOUT_RED
        PlayerLost.SKULL = SKULL
        font = freetype.Font('Assets\\Fonts\\Gtek Technology.ttf', size=14)
        PlayerLost(gl_=self.gl, font_=font, image_=FINAL_MISSION, layer_=0)
        # todo kill player 1 and 2 game is over

    def explode(self):
        Explosion.images = EXPLOSION2
        for i in range(10):
            Explosion(self, (self.rect.centerx + randint(-400, 400),
                             self.rect.centery + randint(-400, 400)),
                      self.gl, 8, self.layer,
                      texture_name_='EXPLOSION2', mute_=False if i > 0 else True)

        PlayerHalo.images = HALO_SPRITE13
        PlayerHalo.containers = self.gl.All
        PlayerHalo(texture_name_='HALO_SPRITE13', object_=self, timing_=8)
        self.quit()

    def collide(self, damage_: int)-> None:
        """
        Asteroid collide with object (e.g Asteroids)
        :param damage_: int; damage transfer to the transport (damage must be positive)
        :return: None
        """
        assert isinstance(damage_, int), \
            'Positional arguement damage_, expecting int type got %s ' % type(damage_)
        if self.alive():
            if damage_ is None or damage_ < 0:
                raise ValueError('positional arguement damage_ cannot be None or < 0.')
            self.impact = True      # variable used for blending, (electric effect on the transport's hull )
            self.index = 0
            self.life -= damage_    # Transport life decrease
            # Play an impact sound locally
            self.gl.MIXER.play(sound_=IMPACT1, loop_=False, priority_=0,
                               volume_=1.0, fade_out_ms=0, panning_=True,
                               name_='IMPACT1', x_=self.rect.centerx,
                               object_id_=id(IMPACT1),
                               screenrect_=self.gl.SCREENRECT)
            # Play impact sound on client computer.
            self.impact_sound_object.play()
        else:
            self.quit()
            
    def hit(self, damage_):
        if self.alive():
            self.life -= damage_
        else:
            self.quit()

    def get_centre(self) -> tuple:
        return self.rect.center

    def display_fire_particle_fx(self) -> None:
        # Display fire particles when the player has taken bad hits
        # Use the additive blend mode.
        if self.fxdt > self.timing:
            for p_ in self.vertex_array:

                # queue the particle in the vector direction
                p_.rect.move_ip(p_.vector)
                p_.image = p_.images[p_.index]
                if p_.index > len(p_.images) - 2:
                    p_.kill()
                    self.vertex_array.remove(p_)

                p_.index += 1
            self.fxdt = 0
        else:
            self.fxdt += self.gl.TIME_PASSED_SECONDS

    def fire_particles_fx(self,
                          position_,  # particle starting location (tuple or pygame.math.Vector2)
                          vector_,    # particle speed, pygame.math.Vector2
                          images_,    # surface used for the particle, (list of pygame.Surface)
                          layer_=0,   # Layer used to display the particles (int)
                          blend_=pygame.BLEND_RGB_ADD  # Blend mode (int)
                          ) -> None:
        # Create fire particles around the aircraft hull when player is taking serious damages

        # Cap the number of particles to avoid lag
        # if len(self.gl.FIRE_PARTICLES_FX) > 100:
        #    return
        # Create fire particles when the aircraft is disintegrating
        sprite_ = pygame.sprite.Sprite()
        self.gl.All.add(sprite_)
        # self.gl.FIRE_PARTICLES_FX.add(sprite__)
        # assign the particle to a specific layer
        if isinstance(self.gl.All, pygame.sprite.LayeredUpdates):
            self.gl.All.change_layer(sprite_, layer_)
        sprite_.layer = layer_
        sprite_.blend = blend_  # use the additive mode
        sprite_.images = images_
        sprite_.image = images_[0]
        sprite_.rect = sprite_.image.get_rect(center=position_)
        sprite_.vector = vector_  # vector
        sprite_.index = 0
        # assign update method to self.display_fire_particle_fx
        # (local method to display the particles)
        sprite_.update = self.display_fire_particle_fx
        self.vertex_array.append(sprite_)

    def quit(self) -> None:
        Broadcast.remove_object_id(self.id_)
        obj = Broadcast(self.delete_object())
        obj.queue()
        self.kill()

    def update(self):

        self.rect.clamp_ip(self.safe_zone)

        self.image = self.image_copy.copy()

        # in the 16ms area (60 FPS)
        if self.dt > self.timing:

            if self.life < self.half_life:
                position = pygame.math.Vector2(randint(-50, 50), randint(-100, 100))
                self.fire_particles_fx(position_=position + pygame.math.Vector2(self.rect.center),
                                       vector_=pygame.math.Vector2(uniform(-1, 1), uniform(+1, +3)),
                                       images_=FIRE_PARTICLES,
                                       layer_=0, blend_=pygame.BLEND_RGB_ADD)
            if self.life < 1:
                self.explode()
                return

            if self.previous_pos == self.rect.center:
                self.rect.centerx += randint(-1, 1)
                self.rect.centery += randint(-1, 1)

            if self.gl.FRAME < 100:
                self.rect.centery -= 3

            self.previous_pos = self.rect.center
            self.engine.update()

            self.transport_object.update(
                {'frame': self.gl.FRAME, 'rect': self.rect,
                 'damage': self.damage, 'life': self.life, 'impact': self.impact})
            # Broadcast the spaceship position
            self.transport_object.queue()
            self.dt = 0

        else:
            self.dt += self.gl.TIME_PASSED_SECONDS

        # outside the 60 FPS area.
        # Below code processed every frames.
        if self.impact:
            self.image.blit(DISRUPTION_ORG[self.index % len(DISRUPTION_ORG) - 1],
                            (0, 0), special_flags=pygame.BLEND_RGB_ADD)
            self.index += 1
            if self.index > len(DISRUPTION_ORG) - 2:
                self.impact = False
                self.index = 0