After playing around with King Leo's rewrite, I came up with some interesting ideas:
- Repeats - ||: and :||# border the area you want repeated with # being the number of times to repeat the section. Would actually make repeated parts more noticeable and cuts down on the filesize/string length as a small bonus.
- Ignored characters in files - Find some way to make it skip past newline characters (the places where you pressed return) so we can have more readable files (e.g. one bar per line, empty lines between sections of a piece, etc.) as well as have // represent comments which ignore the rest of the line until a newline character is reached. (i.e. when // shows up, set an ignore flag until a newline character is reached, then unset it.)
- Turn this into named brick relay sequencer? - Have everything before "special characters" in a word define the name of the brick, then find that brick and fire a relay on it. "Special characters" of course include / , * ||: :|| and whatever else gets added. This way we could make relayed sequences much more easily for things like player pianos, light shows, pyrotechnics displays, or even timed cutscenes and scenarios!
What do you think of these ideas? Would they be helpful? How easily could they be implemented?
Hmm. Those are some nice ideas. I don't know if all of this is possible, though.
Skipping newline characters can be avoided by making the program read the file line after line. The problem with that is that all the lines will play simultaneously, and only as long as the shortest line plays (or something like that, it was really weird). I could look into that again.
Repeats would require a complete processing of the string before it is actually played. Right now each new word is being treated as a note (or the lack of one), and the words are played in succession. That would obviously not work with ||: and :||, as there is no way to go back to the first ||: and play it again.
One solution would be to have the function recognize the symbol and skip to the next :||, saving everything in between as a string and passing it recursively to itself X times (typically 2 for a double repeat). That sounds like quite of a challenge, especially if ||: and :|| are on two different lines.
A brick relay sequencer you say? Do you mean that I have a brick called "AS5" that includes the event "onRelay -> Self -> playSound [pianoAS5]", and so on and so forth for every note? That would of course defeat the purpose of a easy-to-set-up-piano event, as the user would have to build and event the piano by himself. And going through relays isn't quite as effective as playing the sound directly. All in all, this reminds me very much of
this and
this, which I built a while ago. The only thing that would be different is the calling sequence, which is done with relayed bricks right now.
On the other hand, this would allow for some cool new things. It gives you more freedom in choosing the right soundpack. That would allow for a multi-instrument orchestra, for example. Another possibility would be (as you said) to use this for light shows and pyrotechnics.
I feel like this should be a variation of the current version, as the functionality is quite different from what we have right now. The good thing is that this is probably very easy to implement.
What do you think?
