Example #1
0
def test_change_state():
    """Test pour la méthode change_state."""
    main.initialization(False)
    player = plyr.Player()
    player.change_state('little')
    assert player.width, player.height == cf.SIZE["little"]
    player.change_state('big')
    assert player.width, player.height == cf.SIZE["big"]
Example #2
0
def test_buttonimage(position, size, mouse):
    """Test pour la classe ButtonImage."""
    main.initialization(False)
    button = mn.ButtonImage(position, size,
                            os.path.join(cf.UI, "multiplayer.png"),
                            os.path.join(cf.UI, "multiplayerpushed.png"))
    button.print(mouse)
    button.print(position)
    button.changlang("fr")
    assert button.lang == "fr"
    button.changlang("en")
    assert button.lang == "en"
Example #3
0
def test_move(velx, vely):
    """Test pour la méthode move de la classe Player."""
    main.initialization(False)
    spt.ground = ut.group_sprite_define()
    player = plyr.Player()
    xinit, yinit = player.pos.x, player.pos.y
    player.vel = ut.Vec(velx, vely)
    player.move()
    vely += player.acc.y
    assert player.pos.x <= xinit + velx + 0.5 * player.acc.x + 0.001\
        and player.pos.x >= xinit + velx + 0.5 * player.acc.x - 0.001
    assert player.pos.y <= yinit + vely + 0.5 * player.acc.y + 0.001\
        and player.pos.y >= yinit + vely + 0.5 * player.acc.y - 0.001

    player.timer = 1
    player.state = "little"
    player.move()
    assert player.state == "normal"
    player.state = "fast"
    player.move()
    assert player.vel.x == cf.V_ITEM["fast"]
    player.pos.x = (3 * cf.SCREEN_WIDTH) // 4
    player.move()
    assert player.vel.x == 0
    player.state = "slow"
    player.move()
    assert player.vel.x == cf.V_ITEM["slow"]
    player.pos.x = -player.width // 2
    player.move()
    assert player.vel.x == 0

    player.state = "normal"
    item = it.Item()
    item.pos = player.pos
    item.update()
    ut.add_to_group(item, spt.items)
    player.vel = ut.Vec((0, 0))
    player.acc = ut.Vec((0, 0))
    player.move()
    assert player.state != "normal"

    player.state = 'delay'
    player.timer = 1
    player.move()
    assert player.state == "big"
Example #4
0
def test_inputzone(position, size):
    """Test pour la classe InputZone."""
    main.initialization(False)
    zone = mn.InputZone(position, size)
    zone.print()
    assert not zone.selected
    zone.select()
    assert zone.selected
    zone.deselect()
    assert not zone.selected
    zone.select()
    zone.read(ut.K_s)
    zone.read(ut.K_SPACE)
    assert zone.input == "S "
    zone.read(ut.K_BACKSPACE)
    assert zone.input == "S"
    zone.read(ut.K_BACKSPACE)
    zone.deselect()
    zone.read(ut.K_s)
    assert zone.input == ""
Example #5
0
def test_end_item():
    """Test pour la méthode end_item."""
    main.initialization(False)
    player = plyr.Player()
    player.vel.x = cf.V_ITEM['fast']
    player.change_state('little')
    player.end_item()
    assert player.width, player.height == cf.SIZE["normal"]
    assert player.vel.x == 0

    player.vel.x = cf.V_ITEM['slow']
    player.change_state('big')
    player.end_item()
    assert player.width, player.height == cf.SIZE["normal"]
    assert player.vel.x == 0

    # Délai en cas d'obstacle
    plat = plt.Platform(player.pos, (1, 1))
    ut.add_to_group(plat, spt.ground)
    player.state = 'little'
    player.end_item()
    assert player.width, player.height == cf.SIZE["little"]
Example #6
0
def test_jump():
    """Test pour la méthode de saut de la classe Player."""
    cf.NB_PLAYERS = 1
    _, player = main.initialization(False)
    player = player[0]
    cf.STATE = cf.State.ingame
    # Lancement du saut
    player.jump()
    assert player.vel.y == -cf.V_JMP
    # Quelques tours de boucle
    for _ in range(10):
        gml.main_loop([player], False)
    # Vitesse finale, avec précision prise en compte
    assert player.vel.y <= -cf.V_JMP + 10 * cf.G + 0.001\
        and player.vel.y >= -cf.V_JMP + 10 * cf.G - 0.001
    # Vérification de la possibilité d'un double saut
    player.jump()
    assert player.vel.y == -cf.V_JMP
Example #7
0
def test_run():
    """
    Fais un test de run classique.

    Lance le jeu, clique sur jouer,
    et simule des sauts et des doubles sauts
    Parameters
    ----------
    nstep : int
        le nombre de secondes à effectuer
    """
    cf.NB_PLAYERS = 1
    # timer pour faire un double saut
    timer = 0
    _, players = main.initialization(False)
    # clique sur jouer à un joueur
    pos = mn.oneplayer_button.position
    players = gml.event_handling(players, clic(pos), pos)
    # boucle de jeu
    while players[0].alive:

        # Si on peut sauter, on saute
        if players[0].FLAG_JUMP:
            players = do_event(players, jump())
            timer = 20
        # Puis on fait un double saut 10 frames plus tard
        if timer == 0 and players[0].FLAG_JUMP_2:
            players = do_event(players, jump())
        else:
            timer -= 1

        wrld.update()  # Mise à jour de l'environnement

        players = gml.main_loop(players, (0, 0))

        assert cf.STATE == cf.State.ingame
    # on est mort
    players = gml.main_loop(players, (0, 0))
    assert cf.STATE == cf.State.gameover
Example #8
0
def test_buttontext(position, size, mouse, label):
    """Test pour la classe ButtonText."""
    main.initialization(False)
    button = mn.ButtonText(position, size, label)
    button.print(mouse)
Example #9
0
def test_main_loop_event():
    """Test pour la fonction main_loop."""
    cf.NB_PLAYERS = 3
    _, players = main.initialization(False)
    assert len(players) == 3

    # Menu
    cf.LANG = "fr"
    cf.STATE = cf.State.menu
    players[0].jump()  # Pour tester move
    players = gml.main_loop(players, (0, 0))
    assert players[0].vel.y != 0

    # Setup (simple appel pour créer les boutons)
    cf.STATE = cf.State.setup
    players = gml.main_loop(players, (0, 0))
    players = gml.reset_world()

    # Languages
    cf.STATE = cf.State.languages
    players = gml.main_loop(players, (0, 0))

    # Langchange
    cf.STATE = cf.State.langchange
    players = gml.main_loop(players, (0, 0))
    players = gml.reset_world()

    # Multiplayer_set
    cf.STATE = cf.State.multiplayer_set
    players = gml.main_loop(players, (0, 0))
    players = gml.reset_world()

    # Keyset
    cf.STATE = cf.State.keyset
    players = gml.main_loop(players, (0, 0))
    cf.CAPT = True
    players = gml.main_loop(players, (0, 0))

    cf.NB_PLAYERS = 3
    players = gml.reset_world()

    # In game
    cf.FRAMES = 0
    cf.STATE = cf.State.ingame
    for _ in range(60):
        players = gml.main_loop(players, (0, 0))
    assert cf.FRAMES == 60
    assert cf.SECONDS == 1
    players[0].pos = ut.Vec(-100, -100)  # Joueur 1 a perdu
    players = gml.main_loop(players, (0, 0))
    assert not players[0].alive
    assert cf.STATE == cf.State.ingame
    players[1].pos = ut.Vec(-100, -100)  # Joueur 2 a perdu
    players = gml.main_loop(players, (0, 0))
    players = gml.main_loop(players, (0, 0))
    assert not players[1].alive
    assert cf.STATE == cf.State.gameover_multi
    assert plyr.WINNER == 2

    cf.NB_PLAYERS = 1
    cf.STATE = cf.State.ingame
    players = gml.reset_world()
    assert len(players) == 1
    players[0].pos = ut.Vec(-100, -100)
    cf.SECONDS = 30  # Record pour l'étape suivante
    players = gml.main_loop(players, (0, 0))
    players = gml.main_loop(players, (0, 0))
    assert cf.STATE == cf.State.gameover

    # Game over
    cf.CAPT = True
    players = gml.main_loop(players, (0, 0))
    cf.CAPT = False
    scre.PLAYER = "test"
    scre.set_best_score(cf.SECONDS)
    players = gml.main_loop(players, (0, 0))
    assert cf.NEWHS
    assert cf.NEWRC
    assert scre.get_scores()[0][0] == 30
    assert scre.get_best_score() == 30
    players = gml.reset_world()
    cf.STATE = cf.State.ingame
    cf.SECONDS = 29
    players[0].alive = False
    players = gml.main_loop(players, (0, 0))
    assert cf.STATE == cf.State.gameover
    cf.CAPT = False
    scre.PLAYER = "test"
    scre.set_best_score(cf.SECONDS)
    players = gml.main_loop(players, (0, 0))
    assert scre.get_best_score() == 30
    assert cf.NEWHS
    assert not cf.NEWRC
    assert scre.get_scores()[1][0] == 29

    # Game over multi
    cf.STATE = cf.State.gameover_multi
    # Simple appel à la fonction
    players = gml.main_loop(players, (0, 0))

    cf.STATE = cf.State.credits
    players = gml.main_loop(players, (0, 0))

    # Highscores
    cf.STATE = cf.State.highscore
    # Appel avec un tableau non vide
    players = gml.main_loop(players, (0, 0))
    scre.init_best_score()  # Suppression du contenu
    # Appel avec un tableau vide
    players = gml.main_loop(players, (0, 0))
Example #10
0
def test_event():
    """Test pour la fonction event_handling."""
    _, players = main.initialization(False)

    # Test pour KEY_DOWN
    cf.STATE = cf.State.ingame
    for i, P in enumerate(players):
        event = ut.make_event(ut.KEYDOWN, {'key': plyr.JUMP_KEYS[i]})
        players = gml.event_handling(players, event, (0, 0))
        assert P.vel.y == -cf.V_JMP

    cf.CAPT = True
    cf.STATE = cf.State.keyset
    players = gml.event_handling(
        players, ut.make_event(ut.KEYDOWN, {'key': ut.K_ESCAPE}), (0, 0))
    assert not cf.CAPT

    cf.CAPT_PLYR = 1
    cf.CAPT = True
    players = gml.event_handling(players,
                                 ut.make_event(ut.KEYDOWN, {'key': ut.K_s}),
                                 (0, 0))
    assert not cf.CAPT
    assert plyr.JUMP_KEYS[1] == ut.K_s

    cf.STATE = cf.State.gameover
    cf.CAPT = True
    mn.player_name_area.select()
    players = gml.event_handling(players,
                                 ut.make_event(ut.KEYDOWN, {'key': ut.K_s}),
                                 (0, 0))
    assert mn.player_name_area.input == 'S'
    players = gml.event_handling(
        players, ut.make_event(ut.KEYDOWN, {'key': ut.K_RETURN}), (0, 0))
    assert scre.PLAYER == 'S'
    assert not cf.CAPT
    assert not mn.player_name_area.selected

    cf.NB_PLAYERS = 3
    players = gml.reset_world()

    # Tests pour MOUSEBUTTONDOWN
    cf.STATE = cf.State.menu
    players[0].jump()
    event = ut.make_event(ut.MOUSEBUTTONDOWN)
    players = gml.event_handling(players, event, mn.Oneplayer_pos)
    assert cf.NB_PLAYERS == 1
    assert players[0].vel.y == 0
    assert cf.STATE == cf.State.ingame
    for bloc in spt.ground:
        assert not bloc.FLAG_creation

    cf.STATE = cf.State.menu
    players = gml.event_handling(players, event, mn.Multiplayer_pos)
    players = gml.event_handling(players, event,
                                 mn.Multi_pos[cf.NB_PLAYERS_MAX - 2])
    assert cf.NB_PLAYERS == 4
    players = gml.event_handling(players, event, mn.Start_pos)
    assert players[0].vel.y == 0
    assert cf.STATE == cf.State.ingame
    for bloc in spt.ground:
        assert not bloc.FLAG_creation

    cf.STATE = cf.State.menu
    players = gml.event_handling(players, event, mn.Records_pos)
    assert cf.STATE == cf.State.highscore

    cf.STATE = cf.State.menu
    players = gml.event_handling(players, event, mn.Settings_pos)
    assert cf.STATE == cf.State.setup

    cf.STATE = cf.State.languages
    lg.set_lang(lg.AVAILABLE[0])
    players = gml.event_handling(players, event, mn.Flag_pos[1])
    assert cf.STATE == cf.State.menu
    assert cf.LANG == lg.AVAILABLE[1]

    cf.STATE = cf.State.languages
    lg.set_lang(lg.AVAILABLE[1])
    players = gml.event_handling(players, event, mn.Flag_pos[0])
    assert cf.STATE == cf.State.menu
    assert cf.LANG == lg.AVAILABLE[0]

    cf.STATE = cf.State.multiplayer_set
    players = gml.event_handling(players, event, mn.Multi_pos[1])
    assert cf.NB_PLAYERS == 3
    players = gml.event_handling(players, event, mn.Return_pos)
    assert cf.STATE == cf.State.menu
    cf.STATE = cf.State.multiplayer_set
    players = gml.event_handling(players, event, mn.Start_pos)
    assert cf.STATE == cf.State.ingame

    cf.STATE = cf.State.langchange
    players = gml.event_handling(players, event, mn.Flag_pos[0])
    assert cf.STATE == cf.State.setup
    assert cf.LANG == lg.AVAILABLE[0]

    cf.STATE = cf.State.langchange
    players = gml.event_handling(players, event, mn.Flag_pos[1])
    assert cf.STATE == cf.State.setup
    assert cf.LANG == lg.AVAILABLE[1]

    cf.STATE = cf.State.langchange
    lg.set_lang(lg.AVAILABLE[0])
    players = gml.event_handling(players, event, mn.Return_pos)
    assert cf.STATE == cf.State.setup
    assert cf.LANG == lg.AVAILABLE[0]

    cf.STATE = cf.State.gameover
    players[0].jump()
    players = gml.event_handling(players, event, mn.Return_pos)
    assert players[0].vel.y == 0
    assert cf.STATE == cf.State.menu

    cf.STATE = cf.State.gameover
    players[0].jump()
    players = gml.event_handling(players, event, mn.Restart_pos)
    assert players[0].vel.y == 0
    for bloc in spt.ground:
        assert not bloc.FLAG_creation
    assert cf.STATE == cf.State.ingame

    cf.STATE = cf.State.highscore
    players = gml.event_handling(players, event, mn.Return_pos)
    assert cf.STATE == cf.State.menu

    cf.STATE = cf.State.setup
    players = gml.event_handling(players, event, mn.Language_pos)
    assert cf.STATE == cf.State.langchange

    cf.CAPT = True
    cf.STATE = cf.State.setup
    players = gml.event_handling(players, event, mn.Commands_pos)
    assert cf.STATE == cf.State.keyset
    assert not cf.CAPT

    cf.STATE = cf.State.credits
    players = gml.event_handling(players, event, mn.Return_pos)
    assert cf.STATE == cf.State.menu

    cf.STATE = cf.State.menu
    players = gml.event_handling(players, event, mn.Credits_pos)
    assert cf.STATE == cf.State.credits

    cf.STATE = cf.State.setup
    players = gml.event_handling(players, event, mn.Return_pos)
    assert cf.STATE == cf.State.menu

    cf.STATE = cf.State.keyset
    players = gml.event_handling(players, event, mn.Return_pos)
    assert cf.STATE == cf.State.setup

    cf.CAPT = False
    cf.STATE = cf.State.keyset
    players = gml.event_handling(players, event, ky.Modify_pos[2])
    assert cf.CAPT
    assert cf.CAPT_PLYR == 2