Main Character Player Testing - UQdeco2800/2021-ext-studio-2 GitHub Wiki

Sprint 1

There was no need to write unit tests to test out sprite integration and sprite animations, mainly due to the visual nature of the contributions made by our team in this feature sprint. The creation and integration of player image, movement, and animation were done using built-in classes and required no extra testing. The testing of the feature integration was done by asking users to play the game and share their views on the positioning of the character and the movement animation of the character. The required changes were then made to the code.

Sprint 2

Considering it is hard to test whether an animation plays because of its visual nature, unit tests were written to verify and validate the generated texture atlas and animation packs instead. The tests check that all the expected animations actually exist in the atlas, in order to catch bugs when editing/renaming/deleting animations.

PlayerAnimationAtlasTest.java

@ExtendWith(GameExtension.class)
class PlayerAnimationAtlasTest {


    @Test
    void shouldLoadTextureAtlases() {
        String asset1 = "test/files/mpcAnimation.atlas";
        String asset2 = "test/files/test2.atlas";
        String[] textures = {asset1, asset2};


        AssetManager assetManager = new AssetManager();
        ResourceService resourceService = new ResourceService(assetManager);
        resourceService.loadTextureAtlases(textures);

        assetManager.load(asset1, TextureAtlas.class);
        assetManager.load(asset2, TextureAtlas.class);

        TextureAtlas atlas = new TextureAtlas(Gdx.files.internal(asset1));
        AnimationRenderComponent testAnimator = new AnimationRenderComponent(atlas);

        ObjectSet<Texture> texture = atlas.getTextures();
        String tex = texture.toString();
        assertEquals("{test/files/mpcAnimation.png}",tex);

        testAnimator.addAnimation("main_player_run", 1f);
        assertTrue(testAnimator.hasAnimation("main_player_run"));
        ...
        assertNotNull(atlas.findRegion("main_player_run"));
        assertTrue(testAnimator.hasAnimation("main_player_run"));

Sprint 3

Considering it is hard to test whether an animation plays because of its visual nature, unit tests were written to verify and validate the generated texture atlas and animation packs instead. The tests check that all the expected animations actually are started, when a corresponding event is triggered by the player/ user inputs, in order to catch bugs when triggering/starting an animation.

PlayerAnimationRenderTest.java

@ExtendWith(GameExtension.class)
class PlayerAnimationRenderTest {

    private Entity player;
    private AnimationRenderComponent animator;
    @BeforeEach
    void beforeEach() {
        ServiceLocator.registerPhysicsService(new PhysicsService());
        player = new Entity()
                .addComponent(new PhysicsComponent())
                .addComponent(new PlayerAnimationController());

        animator = mock(AnimationRenderComponent.class);
        player.addComponent(animator);

        PlayerAnimationController animationController =
                player.getComponent(PlayerAnimationController.class);
        animationController.setTexturePresent(false);
        player.create();
    }


    @Test
    void shouldTriggerRightMovement() {
        player.getEvents().trigger("walkRight");
        verify(animator).startAnimation("main_player_run");
    }

    @Test
    void shouldTriggerWalkMovement() {
        player.getEvents().trigger("startMPCAnimation");
        verify(animator).startAnimation("main_player_walk");
    }

    @Test
    void shouldTriggerJumpMovement() {
        player.getEvents().trigger("jump");
        verify(animator).startAnimation("main_player_jump");
    }

    @Test
    void shouldTriggerCrouchMovement() {
        player.getEvents().trigger("crouch");
        verify(animator).startAnimation("main_player_crouch");
    }

    @Test
    void shouldTriggerItemPickUpMovement() {
        player.getEvents().trigger("itemPickUp");
        verify(animator).startAnimation("main_player_pickup");
    }

    @Test
    void shouldTriggerAttackMovement() {
        player.getEvents().trigger("attack");
        verify(animator).startAnimation("main_player_attack");
    }
}

NOTE: For demo and testing purposes, all the attires are unlocked by default for now. This was done by hard coding the number of unlocked gold achievements to >6.

Sprint 4

We've added animation atlas tests for the new burn and hurt animations PlayerAnimationAtlasTest.java

        testAnimator.addAnimation("main_player_right", 1f);
        assertTrue(testAnimator.hasAnimation("main_player_right"));

        testAnimator.addAnimation("main_player_hurt", 1f);
        assertTrue(testAnimator.hasAnimation("main_player_hurt"));

        testAnimator.addAnimation("main_player_burn", 1f);
        assertTrue(testAnimator.hasAnimation("main_player_burn"));

        assertNotNull(atlas.findRegion("main_player_right"));
        assertTrue(testAnimator.hasAnimation("main_player_right"));

        assertNotNull(atlas.findRegion("main_player_hurt"));
        assertTrue(testAnimator.hasAnimation("main_player_hurt"));

        assertNotNull(atlas.findRegion("main_player_burn"));
        assertTrue(testAnimator.hasAnimation("main_player_burn"));

We've also included new unit tests to verify the triggering of the new animations. PlayerAnimationRenderTest.java

 @Test
    void shouldTriggerBurnMovement() {
        player.getEvents().trigger("burn");
        verify(animator).startAnimation("main_player_burn");
    }

    @Test
    void shouldTriggerHurtMovement() {
        player.getEvents().trigger("hurt");
        verify(animator).startAnimation("main_player_hurt");
    }

    @Test
    void shouldTriggerWalkRightMovement() {
        player.getEvents().trigger("stopAnimations");
        verify(animator).startAnimation("main_player_walk");
    }

Future Directions

In the future sprints, the integration between player buff animation and the actual functionality that riggers them will be unit tested comprehensively. The animation atlas can be generated programmatically instead of manually, in order to allow designers to test out new sprite designs without having to regenerate the whole texture atlas every time.