예제 #1
0
def load_game(load, random):
    """
    loads the game and thus all ships and control lists
    when game is not newly created, skips creation steps and loading from saves instead

    :param load: bool; game is loaded and not newly created
    :param random: bool; ships are set randomly and not by the player
    """
    if load:
        random = True
    check_list = [
        True
    ]  # creates a check list to prevent a failed loading attempt to break the game
    while True in check_list:  # game has not been loaded successfully yet
        if check_list.__len__(
        ) > 1:  # loop is running for a second time, thus loading has failed
            load = False  # game is newly created
            add_system_message(
                "loadingfailure"
            )  # displays system message informing about missing file when loading

        check_list = [  # updates list to check for failed loadings; [False, False, False, False] when successful
            # loads/creates player's check lists
            pl.__init__player(load, resource_path, lg.get_language(),
                              lg.get_difficulty() + "/"),
            sh.__init__ship(load, get_dif_number),  # loads/creates ships
            vo.__init__playfield(
                resource_path,
                load,
                lg.get_language(),  # loads/creaetes board
                vo.get_window_size(vo.get_screen_size()[0],
                                   vo.get_screen_size()[1])[3],
                lg.get_difficulty() + "/")
        ]
        # sets ships to corect locations
        if random:
            check_list.append(
                sh.set_ships(
                    load, resource_path, lg.get_language(),
                    lg.get_difficulty() + "/",
                    vo.get_window_size(vo.get_screen_size()[0],
                                       vo.get_screen_size()[1])[2]))
        else:
            sh.set_ships(
                load, resource_path, lg.get_language(),
                lg.get_difficulty() + "/",
                vo.get_window_size(vo.get_screen_size()[0],
                                   vo.get_screen_size()[1])[2], False)
            return True
        # loads/creates enemy's moves
        check_list.append(
            en.__init__enemy(load,
                             lg.get_language(),
                             resource_path,
                             10,
                             10,
                             ship_coordinates=sh.get_ship_positions(),
                             ships=sh.get_ship(),
                             difficulty=lg.get_difficulty(),
                             add_dir=lg.get_difficulty() + "/"))
예제 #2
0
def save_game():
    """
    saves the game to the saves directory
    """
    en.save_enemy(resource_path, lg.get_language(),
                  lg.get_difficulty() +
                  "/")  # saves the remaining moves of the enemy
    pl.save_player(resource_path, lg.get_language(),
                   lg.get_difficulty() + "/")  # saves already targeted fields
    sh.save_ship(resource_path, lg.get_language(),
                 lg.get_difficulty() + "/")  # saves the ships
    vo.save_playfield(resource_path, lg.get_language(),
                      lg.get_difficulty() + "/")  # saves the playfield
    add_system_message("save")  # shows confirmation in chat
예제 #3
0
def ingame(settings, running, win, again):
    """
    loops that are active in game

    settings loop allowing for visual changes

    game loop allowing game to be played

    :param settings: bool; settings loop is running
    :param running: bool; game loop is running
    :param win: int; player that is currently winning
    :param again: bool; game is datting from beginning after current game ends
    :return: int, bool; updated bool for loop management
    """

    vo.refresh_loc_coords(
        vo.get_window_size(vo.get_screen_size()[0],
                           vo.get_screen_size()[1])[2],
        vo.get_window_size(vo.get_screen_size()[0],
                           vo.get_screen_size()[1])[3], lg.get_zustand())
    # displays the menu on the game window
    vo.draw_screen(lg.get_zustand(), lg.get_background(), lg.get_language(),
                   sh.get_ship(), resource_path, lg.get_task_number())

    while settings or running:
        # ------
        # settings loop
        settings, running, win, again = setting(settings, running, win, again)

        # ------
        # game loop
        settings, running, win, again = game_loop(settings, running, win,
                                                  again)

    return win, again
예제 #4
0
def add_system_message(message):
    """
    adds a system message to be displayed in chat
    :param message: str; message that i sdisplayed
    """
    dictionary = get_dict(
        lg.get_language(),
        "message")  # gets the correcct dictionary to translate message
    message = dictionary["System"] + dictionary[message]  # translates message
    chat.add_message(message, (50, 50, 0))  # displays message in dark yellow
예제 #5
0
def video_resize(size, ship=[[[0]]], draw=True):
    vo.set_screen_size(size[0], size[1])  # refreshes window size
    # refreshes location of visible assets and the game itself
    vo.refresh_loc_coords(
        vo.get_window_size(size[0], size[1])[2],
        vo.get_window_size(size[0], size[1])[3], lg.get_zustand())
    if draw:
        # displays the menu on the game window
        vo.draw_screen(lg.get_zustand(), lg.get_background(),
                       lg.get_language(), ship, resource_path,
                       lg.get_task_number(), lg.get_settings())
예제 #6
0
def set_player(play):
    """
    refreshes current palyer and executes enemy's move

    :param play: int; which player has to complete a move next (0 player, 1 enemy)
    """
    global player
    global move
    player = play  # refreshes current player
    if player == 1:  # checks whether this is the enemy's move
        move[get_dif_number()] += 1
        # displays the game on the game window
        vo.draw_screen(lg.get_zustand(), lg.get_background(),
                       lg.get_language(), sh.get_ship(), resource_path,
                       lg.get_task_number())
        time.sleep(0.75)  # waits 2 seconds to simulate the enemy thinking
        _do_enemy_move()  # executes enemy's move
        # displays the game on the game window
        vo.draw_screen(lg.get_zustand(), lg.get_background(),
                       lg.get_language(), sh.get_ship(), resource_path,
                       lg.get_task_number())
    player = 0  # sets the player back to the player
예제 #7
0
def do_hit_player_input(xcoord_local, ycoord_local):
    """
    does a hit enforced by a player input

    :param xcoord_local: int; x coordinate of the hit
    :param ycoord_local: int; y coordiante of the hit
    """
    if pl.change_hit_list(xcoord_local,
                          ycoord_local):  # changes the list with hit fields
        # hits something on the coordiantes of the hit
        sh.hit_something(xcoord_local, ycoord_local, 0, resource_path,
                         lg.get_sound_volume(), lg.get_language())
        set_player(
            1)  # executes enemy's move and sets the player back to the player
    else:
        # displays a system message saying that the field was already targeted before
        add_system_message("againhit")
예제 #8
0
def request_load(request, running, settings, win, again):
    """
    displays a request asking to load a game instead of creating a new one

    :param request: bool; request loop is running
    :param running: bool; game loop will be running
    :param settings: bool; in game settings loop will be running
    :param win: int; player that is currently winning the game
    :param again: bool; game will be starting again after this game
    :return: bool, bool, bool, int, bool; updated bools for loop management
    """
    load = False
    random = False
    # creates request buttons
    vo.create_request_buttons(lg.get_background_color_start(),
                              lg.get_writing_color_start(), lg.get_language())
    if request:  # displays the request screen
        vo.draw_request(lg.get_writing_color_start())
    while request:  # request for loading the game

        for event in pg.event.get(
        ):  # goes through every input occuring while game window is in focus

            if event.type == MOUSEBUTTONDOWN:  # mouse button was clicked
                # gets size of one field and orientation
                field_size, orientation = vo.get_window_size(
                    vo.get_screen_size()[0],
                    vo.get_screen_size()[1])[2:]
                load = lg.do_button_start(event.pos[0], event.pos[1],
                                          field_size, vo.get_request_buttons(),
                                          resource_path)
                if load != -1:  # one button is hit
                    request = False  # ends request loop
                    if load == 1:  # ships are randomly set
                        random = True
                        load = False
                    else:  # ships are not set randomly
                        random = False

            elif event.type == pg.QUIT:  # window was closed
                # ends the program
                settings = again = request = running = False
                win = 2
    lg.set_zustand("ingame")
    return random, load, running, settings, win, again
예제 #9
0
def loops():
    """
    program managing all loops in another loop
    """
    global game
    global glost
    global gwon
    global start_time
    game = []
    for _ in DIFFICULTIES:
        game.append(0)
    again = True
    while again:  # program
        begin = running = request = True  # important loops will be running
        settings = False  # settings loop won't be activated without user input
        win = 2  # no winner is determined
        init_program()
        # ------
        # start, settings
        request, running, settings, win, again = begins(
            begin, request, running, settings, win, again)

        # ------
        # game creation
        # asks whether game should be loaded or created
        random, load, running, settings, win, again = request_load(
            request, running, settings, win, again)
        if load_game(
                load, random
        ) and running:  # loads/creates game, True if ships are placed by the player
            settings, again, running, win = ship_placement(
                settings, again, running, win)
        # updates games played/start time stat
        dif_i = get_dif_number()
        game[dif_i] += 1
        start_time[dif_i] = int(time.time() / 60)
        # ------
        # game loop
        win, again = ingame(settings, running, win, again)

        vo.draw_end(
            win, resource_path,
            lg.get_language())  # shows an end screen if a winner is determined
        update_gwon(win)  # updates won/lost stat
예제 #10
0
def _play_music(volume):
    """
    plays the background music

    :param volume: float; volume of the music between 0 and 1
    """
    global channel5
    global music
    channel5 = pg.mixer.Channel(4)  # chooses a channel
    try:
        music = pg.mixer.Sound(
            resource_path("assets/music/deepblue.wav"))  # gets the music
    except FileNotFoundError:
        chat.add_missing_message("deepblue.wav",
                                 resource_path("assets/music/"),
                                 lg.get_language())
    else:
        music.set_volume(volume)  # sets the sound of the music
        channel5.play(music, loops=-1)  # plays the music
예제 #11
0
def _do_enemy_move():
    """
    executes enemy's move
    """
    old_xcoord, old_ycoord, hit = en.get_enemy_move(
    )  # gets the old and new move from the enemy
    sh.hit_something(hit[0], hit[1], 1, resource_path, lg.get_sound_volume(),
                     lg.get_language(), old_xcoord, old_ycoord)  # hits a field

    if lg.get_rule() == 2:  # number of ships determined by proceeding hits
        for x in range(
                sh.get_ship_count()):  # checks whether a ship has been used
            if sh.check_ship_pos(sh.get_ship()[0][x], hit)[0]:
                set_player(1)  # executes another enemy's move

    elif lg.get_rule(
    ) == 3:  # number of ships determines number of shots per move
        # TODO get number of ships, use sh.check_ship_status?
        pass
예제 #12
0
def game_loop(settings, running, win, again):
    """
    game loop, allowing for game to be played

    :param settings: bool; settings loop will be running
    :param running: bool; game is running
    :param win: int; player that is currently winning
    :param again: bool; game will be starting again after this game
    :return: bool, bool, int, bool; bools for loop management
    """
    def set_settings():
        """
        activates settings loop allowing for visual changes to be made by the user
        """
        # updates bools to start settings loop
        nonlocal settings
        nonlocal running
        running = False
        settings = True
        lg.set_aufgabe("main")  # opens main page in menu
        lg.set_zustand("settings")  # sets current loop to current loop

    while running:  # game loop allowing the game to be played

        for event in pg.event.get(
        ):  # goes through every input occuring while game window is in focus

            if event.type == MOUSEBUTTONDOWN:  # button on mouse was pressed
                # gets the size of one virtual field
                field_size = vo.get_window_size(vo.get_screen_size()[0],
                                                vo.get_screen_size()[1])[2]
                button = lg.do_button_mouse_ingame(event.pos[0], event.pos[1],
                                                   field_size,
                                                   vo.get_buttons()[1], gaf(),
                                                   resource_path, save_game)
                try:
                    # gets coordiantes of the clicked field, whether a field was hit, and the hit field
                    xcoord, ycoord, hit_check, xcoord_2, ycoord_2 = button
                except ValueError:
                    # instead puts control values for hit fields if none were hit
                    xcoord, ycoord, hit_check, xcoord_2, ycoord_2 = (-1, -1,
                                                                     False, -1,
                                                                     -1)
                    if button == "end":
                        settings = running = False
                        win = 1
                    elif button == "settings":
                        set_settings()
                except TypeError:
                    # instead puts control values for hit fields if none were hit
                    xcoord, ycoord, hit_check, xcoord_2, ycoord_2 = (-1, -1,
                                                                     False, -1,
                                                                     -1)
                if hit_check:
                    # executes hit if a field was hit
                    do_hit_player_input(xcoord_2, ycoord_2)
                if -1 not in pl.get_last_click():  # checks for control value
                    vo.unclick(pl.get_last_click()
                               )  # unclicks previously clicked field
                pl.set_angeklicktes_feld(xcoord,
                                         ycoord)  # refreshes clicked field
                # displays the game on the game window
                vo.draw_screen(lg.get_zustand(), lg.get_background(),
                               lg.get_language(), sh.get_ship(), resource_path,
                               lg.get_task_number(), lg.get_settings())
                if running:
                    running, win = sh.check_ship_status(
                    )  # checks whether all ships of one player have been destroyed

            elif event.type == KEYDOWN:  # button on keyboard was pressed
                if event.key == K_ESCAPE:  # escape button was pressed
                    set_settings()
                else:
                    try:
                        # gets coordinates of the selected field
                        xcoord, ycoord = lg.do_button_ingame_keyboard(
                            event.key, resource_path)
                    except TypeError:
                        # sets coordinates to -1 when no field is selected yet
                        xcoord, ycoord = -1, -1

                    if xcoord != -1 and ycoord != -1:
                        # clicks a new field
                        hit_small_field(1, xcoord, ycoord, resource_path,
                                        lg.get_sound_volume(),
                                        lg.get_language())
                        do_hit_player_input(
                            xcoord, ycoord)  # hits a field from a player input

                # displays the game on the game window
                vo.draw_screen(lg.get_zustand(), lg.get_background(),
                               lg.get_language(), sh.get_ship(), resource_path,
                               lg.get_task_number(), lg.get_settings())
                running, win = sh.check_ship_status(
                )  # checks whether all ships of one player have been destroyed

            elif event.type == VIDEORESIZE:  # checks whether the size of the window got adjusted
                video_resize(event.size, sh.get_ship())

            elif event.type == pg.QUIT:  # checks whether the wndow has been closed
                # ends the program
                settings = running = again = False
                win = 2  # sets win to 2, what is used to mark that no player has won the game

    return settings, running, win, again
예제 #13
0
def setting(settings, running, win, again):
    """
    settings loop in game, allowing for settings to change that only effect the game visually

    :param settings: bool; settings loop is running
    :param running: bool; game loop will be running
    :param win: int; player that is currently winning
    :param again: bool; game will be starting again after this game
    :return: bool, bool, int, bool; updated bools for loop management
    """
    num = 0
    other_num = 0
    while settings and lg.get_zustand(
    ) != "end":  # settings loop enabling setting changes in game

        for event in pg.event.get(
        ):  # goes through every input occuring while game window is in focus

            if event.type == MOUSEBUTTONDOWN:  # mouse button was clicked
                # gets size of one virtual field
                field_size, orientation = vo.get_window_size(
                    vo.get_screen_size()[0],
                    vo.get_screen_size()[1])[2:]
                # executes feature of pressed button if there is one
                button = lg.do_button_start(event.pos[0], event.pos[1],
                                            field_size,
                                            vo.get_buttons()[0], resource_path)
                if button == "end":
                    settings = running = False
                    win = 1
                if lg.get_aufgabe(
                ) == "volume":  # checks whether a slider is on the screen
                    for slider in vo.get_slides():  # goes through every slider
                        try:
                            if slider.button_rect.collidepoint(
                                    event.pos
                            ):  # checks whether the slider is pressed
                                slider.hit = True  # sets hit to true, so that it will be moved
                        except AttributeError:
                            pass
                # displays the menu on the game window
                vo.draw_screen(lg.get_zustand(), lg.get_background(),
                               lg.get_language(), sh.get_ship(), resource_path,
                               lg.get_task_number(), lg.get_settings())
                other_num = num  # refreshes control number used to fix bug with sliders

            elif event.type == MOUSEBUTTONUP and num != other_num + 1:  # checks whether a mouse button was lifted
                for slider in vo.get_slides():  # goes through every slider
                    slider.hit = False  # sets hit to false, so that it won't be moved
                # displays the menu on the game window
                vo.draw_screen(lg.get_zustand(), lg.get_background(),
                               lg.get_language(), sh.get_ship(), resource_path,
                               lg.get_task_number(), lg.get_settings())

            elif event.type == VIDEORESIZE:  # window size has been adjusted
                video_resize(event.size, sh.get_ship())

            elif event.type == pg.QUIT:  # ueberprueft, ob das Fenster geschlossen wurde
                # ends the program
                settings = running = again = False
                win = 2

        if lg.get_aufgabe(
        ) == "volume":  # checks whether a slider is on the screen
            for slider in vo.get_slides():  # goes through every slider
                if slider.hit:  # checks, whether it is hit
                    # moves the slider and thus changes the value of it
                    slider.move(
                        vo.get_window_size(vo.get_screen_size()[0],
                                           vo.get_screen_size()[1])[2])
                    # displays the volume settings on the game window
                    vo.draw_screen(lg.get_zustand(), lg.get_background(),
                                   lg.get_language(), sh.get_ship(),
                                   resource_path, lg.get_task_number(),
                                   lg.get_settings())

        elif lg.get_aufgabe() == "stats":
            update_statistics()
            # displays the statistics on the game window
            vo.draw_screen(lg.get_zustand(), lg.get_background(),
                           lg.get_language(), sh.get_ship(), resource_path,
                           lg.get_task_number(), lg.get_settings())
            lg.set_aufgabe("statistics")

        if lg.get_zustand() == "ingame":  # game has been started
            settings = False  # continues the game
            running = True
        # continues counting, used to fix a bug instantly having a mousebuttonup event after mousebuttondown
        num += 1
        if num > 254:
            num = 0

        try:
            music.set_volume(lg.get_music_volume()
                             )  # adjusts the volume of the music playing
        except NameError:  # music has not been found
            pass

    return settings, running, win, again
예제 #14
0
def ship_placement(settings, again, running, win):
    """
    loop that allows ships to be set to correct location

    :param settings: bool; settings loop is running
    :param again: bool; game will be starting again after this game
    :param running: bool; game loop will be running
    :param win: int; player that is currently winning
    :return: bool, bool, bool, int; updated bools for loop management
    """
    def try_start():
        """
        tries to start the game, only allows start if all ships have been placed
        :return: bool; ship placement continues
        """
        start = True
        for ship_l in sh.get_ship()[0]:  # goes through player's ships
            if not ship_l.placed:  # ship has not been placed yet
                start = False  # game cannot be started
        return bool(1 - int(start))  # returns inverted start

    lg.set_zustand("placement")  # starts placement loop
    video_resize(vo.get_screen_size(), sh.get_ship(),
                 False)  # updates window's size
    vo.draw_ship_placement(lg.get_zustand(), lg.get_language(),
                           lg.get_background(), resource_path,
                           sh.get_ship())  # displays updated window
    place_ships = True  # starts placement loop
    clock = pg.time.Clock()  # initializes clock to limit frames/second
    while place_ships:  # loop for ships' player controlled placements

        for event in pg.event.get():  # goes through all input events

            if event.type == MOUSEBUTTONDOWN:  # button on mouse is pressed*

                for ship in sh.get_ship()[0]:  # goes through player's ships
                    for i, rect in enumerate(
                            ship.rects):  # goes through ship's Rects
                        if rect.collidepoint(event.pos):  # ship was clicked
                            ship.hit = True  # ship is hit
                            ship.placed = False  # ship is not placed
                            ship.hit_tile = i  # updates hit tile

                vo.draw_ship_placement(
                    lg.get_zustand(), lg.get_language(), lg.get_background(),
                    resource_path, sh.get_ship())  # displays updated placement
                # gets button, important when button was pressed
                button = lg.do_button_mouse_ingame(
                    event.pos[0], event.pos[1],
                    vo.get_window_size(vo.get_screen_size()[0],
                                       vo.get_screen_size()[1])[2],
                    vo.get_placement_buttons(), [-1, -1], resource_path,
                    save_game)

                if button == "start":  # start button was pressed
                    place_ships = try_start()

                elif button == "end":  # abort button was pressed
                    settings = running = place_ships = False  # restarts program

            elif event.type == MOUSEBUTTONUP:  # button on mouse is lifted
                for ship in sh.get_ship()[0]:  # goes through palyer's ships
                    if ship.hit:  # ship is clicked
                        ship.hit = False  # ship is not clicked anymore
                        ship.set_position(
                            vo.get_window_size(vo.get_screen_size()[0],
                                               vo.get_screen_size()[1])[2],
                            resource_path
                        )  # sets ship to a position on the board or back to default
                vo.draw_ship_placement(
                    lg.get_zustand(),
                    lg.get_language(), lg.get_background(), resource_path,
                    sh.get_ship())  # dispalys updated ship placement

            elif event.type == KEYDOWN:  # key on keyboard was pressed

                if event.key == K_LEFT or event.key == K_d:
                    # turns ship by 90 degrees to the left
                    for ship in sh.get_ship()[0]:
                        if ship.hit:
                            ship.turn_left()

                elif event.key == K_RIGHT or event.key == K_a:
                    # turns ship by 90 degrees to the right
                    for ship in sh.get_ship()[0]:
                        if ship.hit:
                            ship.turn_right()

                elif event.key == K_RETURN or event.key == K_KP_ENTER:
                    place_ships = try_start(
                    )  # starts game if all ships have been placed

                vo.draw_ship_placement(lg.get_zustand(), lg.get_language(),
                                       lg.get_background(), resource_path,
                                       sh.get_ship())  # updates output

            elif event.type == VIDEORESIZE:  # window's size has been changed
                video_resize(event.size, sh.get_ship(),
                             False)  # updates window's size
                vo.draw_ship_placement(
                    lg.get_zustand(), lg.get_language(), lg.get_background(),
                    resource_path, sh.get_ship())  # displays updated window

            elif event.type == pg.QUIT:  # game window has been closed
                # ends program
                settings = again = running = place_ships = False
                win = 2

        for ship in sh.get_ship()[0]:
            # goes through player's ships
            if ship.hit:  # ship is clicked on
                # moves ship to current cursor position
                ship.move(
                    vo.get_window_size(vo.get_screen_size()[0],
                                       vo.get_screen_size()[1])[2])
                vo.draw_ship_placement(
                    lg.get_zustand(),
                    lg.get_language(), lg.get_background(), resource_path,
                    sh.get_ship())  # displays updated ship placement

        clock.tick(40)  # limits frames/seconds to 40

    lg.set_zustand("ingame")  # starts game
    en.__init__enemy(False,
                     lg.get_language(),
                     resource_path,
                     10,
                     10,
                     ship_coordinates=sh.get_ship_positions(),
                     ships=sh.get_ship(),
                     difficulty=lg.get_difficulty(),
                     add_dir=lg.get_difficulty() + "/")
    sh.set_ships(False,
                 resource_path,
                 lg.get_language(),
                 lg.get_difficulty() + "/",
                 vo.get_window_size(vo.get_screen_size()[0],
                                    vo.get_screen_size()[1])[2],
                 normal=True)
    return settings, again, running, win  # returns updated bools for loop management
예제 #15
0
def begins(begin, request, running, settings, win, again):
    """
    loop running at the beginning of the game

    shows a menu,
    settings can be changed that impact the next game and are saved for future games

    :param begin: bool; setings loop is running
    :param request: bool; request loop will run
    :param running: bool; game loop will run
    :param settings: bool; settings loop in game will run
    :param win: int; current winner of the game
    :param again: bool; game is repeated from the begin loop to allow for another game to b played
    :return: bool, bool, bool, int, bool; updated bools for loop management
    """
    global start_time
    # displays the menu on the game window
    vo.refresh_loc_coords(
        vo.get_window_size(vo.get_screen_size()[0],
                           vo.get_screen_size()[1])[2],
        vo.get_window_size(vo.get_screen_size()[0],
                           vo.get_screen_size()[1])[3], lg.get_zustand())
    vo.draw_screen(lg.get_zustand(), lg.get_background(), lg.get_language(),
                   [[[0]]], resource_path, lg.get_task_number(),
                   lg.get_settings())
    num = 0
    other_num = 0
    while begin and lg.get_zustand(
    ) != "end":  # begin loop is running and settings can be changed

        for event in pg.event.get(
        ):  # goes through every input occuring while game window is in focus

            if event.type == MOUSEBUTTONDOWN:  # mouse button was clicked
                # gets size of one field and orientation
                field_size, orientation = vo.get_window_size(
                    vo.get_screen_size()[0],
                    vo.get_screen_size()[1])[2:]
                # executes feature of pressed button if there is one
                button = lg.do_button_start(event.pos[0], event.pos[1],
                                            field_size,
                                            vo.get_buttons()[0], resource_path)
                if button == "end":
                    begin = settings = running = request = again = False
                # displays the menu on the game window
                if lg.get_zustand() != "ingame":
                    vo.draw_screen(lg.get_zustand(), lg.get_background(),
                                   lg.get_language(), [[[0]]], resource_path,
                                   lg.get_task_number(), lg.get_settings())
                if lg.get_aufgabe(
                ) == "volume":  # checks whether a slider is on the screen
                    for slider in vo.get_slides():  # goes through every slider
                        try:
                            if slider.button_rect.collidepoint(
                                    event.pos
                            ):  # checks whether the slider is pressed
                                slider.hit = True  # sets hit to true, so that it will be moved
                        except AttributeError:
                            pass
                    other_num = num  # refreshes control number used to fix bug with sliders

            elif event.type == MOUSEBUTTONUP and num != other_num + 1:  # checks whether a mouse button was lifted
                for slider in vo.get_slides():  # goes through every slider
                    slider.hit = False  # sets hit to false, so that it won't be moved
                # displays the menu on the game window
                vo.draw_screen(lg.get_zustand(), lg.get_background(),
                               lg.get_language(), [[[0]]], resource_path,
                               lg.get_task_number(), lg.get_settings())

            elif event.type == VIDEORESIZE:  # window size has been adjusted
                video_resize(event.size)

            elif event.type == pg.QUIT:  # window was closed
                # ends the program
                running = begin = settings = request = again = False
                win = 2

        if lg.get_aufgabe() == "stats":
            update_statistics()
            # displays the statistics on the game window
            vo.draw_screen(lg.get_zustand(), lg.get_background(),
                           lg.get_language(), [[[0]]], resource_path,
                           lg.get_task_number(), lg.get_settings())
            lg.set_aufgabe("statistics")

        elif lg.get_aufgabe(
        ) == "volume":  # checks whether a slider is on the screen
            for slider in vo.get_slides():  # goes through every slider
                if slider.hit:  # checks, whether it is hit
                    # moves the slider and thus changes the value of it
                    slider.move(
                        vo.get_window_size(vo.get_screen_size()[0],
                                           vo.get_screen_size()[1])[2])
                    # displays the volume settings on the game window
                    vo.draw_screen(lg.get_zustand(), lg.get_background(),
                                   lg.get_language(), [[[0]]], resource_path,
                                   lg.get_task_number(), lg.get_settings())

        # continues counting, used to fix a bug instantly having a mousebuttonup event after mousebuttondown
        num += 1
        if num > 254:
            num = 0

        if lg.get_zustand() == "request":  # game has been started
            begin = False  # starts the game

        try:
            music.set_volume(lg.get_music_volume()
                             )  # adjusts the volume of the music playing
        except NameError:  # music could not be found
            pass

    return request, running, settings, win, again