rexim / beatwave Goto Github PK

@IngvarJackal pointed out that building instructions only for NixOS makes the project look like it works only on NixOS. We need to make the instructions more general.

Something similar to the Aseprite's approach: https://github.com/aseprite/aseprite/tree/e8ecbbb4d7f6cda65440943e720901e670aab244/third_party

Areas that you can go to only if you have a certain color. The player can change his/her own color after a certain action.

It will give us more possibilities for describing musical puzzles.

cc @Minoru

Extract tunnel into an entity and implement the entire wall hitting process with communication between Player and Tunnel

Extracted from #10

When the player hits the wall play death animation.

It should have a dedicated folder. Similar to core, beatwave, etc. And should never depend on SFML!

Use case:

AnimatedGroup<float, sf::Vector2f, sf::Color>
circle(10.0f, sf::Vector2f(100.0f, 100.0f), sf::Color::Red);

circle.get<0>().animate(from(10.0f).to(20.0f).during(1000));
circle.get<2>().animate(from(sf::Color::Red).to(sf::Color::Blue).during(1000));

circle.tick(100); // ticks for all of the values in the group

It will allow the following things:

class Circle: public AnimatedGroup<float, sf::Vector2f, sf::Color>
{
public:
    enum Property
    {
        Radius = 0,
        Position,
        Color
    };

    void render(sf::RenderTarget *renderTarget)
    {
        auto radius = get<Radius>();

        sf::CircleShape circle(radius);
        circle.setFillColor(get<Color>());
        circle.setPosition(get<Position>() - sf::Vector2f(radius, radius));
        renderTarget->draw(circle)
    }
};

Circle circle(10.0f, sf::Vector2f(100.0f, 100.0f), sf::Color::Red);
circle.get<Circle::Radius>().animate(from(10.0f).to(20.0f).during(1000));
circle.render(renderTarget);

It should be similar to AnimatedGroup::tick(). It should invoke Animated<T>::stop() for each of the object in the group.

The player should die on hitting the wall

Suggested by @Minoru

Clang provide more meaningful compilation messages than gcc

It should be always be either

from(a).to(b).during(t)

or

from(a).by(da).during(t)

The current implementation allow to change to order of the arguments. We need to make it strict by separating them into different classes. We need at least two new classes: ToBy<T> and During<T>.

from(a: T): ToBy<T>
ToBy<T>::to(a: T): During<T>
ToBy<T>::by(da: T): During<T>
During<T>::during(t: int32_t): AnimationPtr<T>

Pieces

• #108 Implement LinearTransition specialization for colors that performs gamma correction
• #116 Implement gamma correction for Player color transition via map animation combinator

Split in #138

Pieces

• #139 Define level file schema
• #140 Refactor Game class
• #141 Implement Level class
• #151 Investigate Sigmentation Fault on using PathCorrectors by value
• #153 Implement XML constructor for Tunnel
• #152 Implement XML constructor for Player
• #150 Implement XML constructor for path corrector swarm
• #142 Extract the event loop into a separate entity

Description

Design a level with a simple drum sequence using only tunnel turns. Adjust all the transition times as needed.

https://www.conan.io/

Suggested by @ForNeVeR

Probably here https://github.com/rexim/beatwave/blob/35526b427ee839573f6dfe629b1b17e51cf86b70/src/core/util.hpp

Why not? It's simpler and shorter.

Try https://codecov.io/ this time

• https://github.com/bilke/cmake-modules/blob/master/CodeCoverage.cmake
• https://github.com/codecov/example-c

Extracted from #10

Add splat effect to death animation. Simply some random drops flying away from the center of the player.

Right now it can only invoke Animated<T>::tick(). Make it take an std::function and allow it to do what it wants with the animated object.

Pieces

• #79 Add State argument to reset method
• #80 Introduce open linear transition

x.animate(begin(from(0).to(10).during(100))
          .then(to(20).during(500)) // <- don't specify the `from`
          .end())

Extracted from #42

http://www.sfml-dev.org/tutorials/2.0/graphics-view.php

• Move sources to src/ folder
• Make src/ a include root
• Extract core to be reused among the executables

Steps to reproduce

• Start the game
• Play the game and make a couple of turns in tunnel
• Hit the wall to die
• Reset by pressing G

Observed

Player is moved to the beginning of the level hits the wall again and dies again

Expected

The player state should be reset without dying in the middle of the process

We need a better design for describing states and transitions

Because a plain linear transition is boring sometimes.

In LinearAnimationBuilder the operator LinearAnimation<T>* returns a heap allocated object which isn't deleted hence causing a memory leak.

raw pointers donot represent ownership and by giving away the ownership there is a leak.
https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#Ri-raw

use std::unique_ptr instead.

Why the state of Animation class returns by value but not reference?

class Animation
{
    virtual State getCurrentState() const = 0; // <<
};

https://github.com/rexim/beatwave/blob/35526b427ee839573f6dfe629b1b17e51cf86b70/src/beatwave/config.hpp

Close #6

Read http://eli.thegreenplace.net/2014/perfect-forwarding-and-universal-references-in-c

There should be an automatic build (and, in future, test) process. Travis, for example.

http://genbattle.bitbucket.org/blog/2016/01/17/c++-travis-ci/

http://clang.llvm.org/extra/clang-tidy/

Suggested by @keddelzz

Derived from #57 (comment)

See https://github.com/voldyman/mdown/blob/master/.dir-locals.el#L14 for a reference.