Show Posts

This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.


Topics - Hayleia

Pages: [1] 2 3 4
1
Super Smash Bros. Open / [Axe]How To make your own character
« on: September 30, 2014, 12:07:24 pm »
(Still in the works. You can start making your character but nothing guarantees that you'll never need to come back to what you've already written. Spriting doesn't have this kind of risk though. If you are really in an urge to make a character and can't wait for this to be done, you can also have a glance at Fox/Falco's source.)


Random Notes

When using the Axe method, you actually compile as a program then convert it into an appvar. That's why I'll say "program" and "appvar" everywhere without distinction.

If you are fluent with Asm, I'd advise you to use the Asm tutorial instead.

When spriting, be sure that your character is the right size compared to Fox. Here are some of Fox's sprites for reference.


Notes to make your life easier

You can include the SMASHH program into your program. It only includes definitions, not code nor data so you can include it wherever you want in your program.
This will not only be a lot more readable for you to write "°AirNull" than to write "pi00000011" but this will also allow some specification changes (I hope that will never happen but we never know) because if you wrote "°AirNull" everywhere, just change the SMASHH and the °AirNull constant is changed everywhere while if you wrote "pi00000011", you'll have to change them all "by hand".

I'd also advise you to use your own macros, like "38→°FoxGravity" so that you can quickly change a constant everywhere in your program.


How do characters work, without details (you'll have details below)

Basically, they work with states. When your character is standing, doing nothing, it's in a state that we can call the "Standing state". It will leave this state when you press Jump for example, to go to the "Jumping state". Another example is the "Dashing State", that repeats itself (not entirely true) until you stop pressing the arrow key you pressed to start this state, or when you press Jump, etc.


The Header

This is necessary to have the game list your character and not list random appvars that don't have the right header.

The header starts with a one byte number, which for now is 1. This is actually not used for now, but in case specification changes happen (which I still hope will never happen), you'll have to put 2 here then 3, etc so that the program knows which specification your character is following.

You then need to put "SSBOCHAR"[00]. This is what the program uses to check if the appvar is a SSBO character or not.

The following two bytes are the size of the program.

Then, you put a 16x14 icon for the character selection menu (28 bytes).

You finish the header with the name of your character, obviously null-terminated.

For example if you are making Fox, here's what it should look like for now. I didn't say that your Axe source needs to start with a dot followed by the name of the compiled program but you must do that obviously.
Code: [Select]
.FOXP
prgmSMASHH

[]→°FoxBEGIN
[01]
"SSBOCHAR"[00]
Data(°FoxEND-°FoxBEGIN^r)
[00000000000000000000000000000000000000000000000000000000]
"Fox"[00]
[]→°FoxEND


General Information

After the header, you need to put information about your character that SSBO will needs to get quick access to. In that order:
1 byte: gravity (not used anymore, can be recycled for something else)
1 byte: air speed
1 byte: traction
1 byte: max number of jumps (2 in general, 5 for Jigglypuff)
2 bytes: max horizontal speed (not used yet)

Then follow the adresses of states that the program will need to have quick access to. A counter example is the second frame of the Down Aerial. You only access that one after the first frame. That first frame however needs to be quickly accessed to when the player asks for a Down Aerial.
All of those adresses take two bytes.
Since for now you have not written any state and have the adress of none, just put the adress of the standing state everywhere, you'll change that as you go along.

Anyway, in that order:
Standing, Airing, Dashing, GroundJump, AirJump, Landing
AirNeutralSpecial, AirSideSpecial, AirDownSpecial, AirUpSpecial
GroundNeutralSpecial, GroundSideSpecial, GroundDownSpecial, GroundUpSpecial
DashAttack
SideSmash, DownSmash, UpSmash
NeutralAir, ForwardAir, BackAir, DownAir, UpAir
LedgeGrabbed

Just a little precision. Axe compiles program "in" the RAM area it will be executed. For Asm users, I mean there is no way to say .org 0. However, state adresses need to be the ones related to the beginning of the data, not absolute ones assuming the program will be located at a precise location. This is why you'll have to put a "[]→°DB" right after the header and a "-°DB" after all your adresses (and this is why I said at the beginning that if you were fluent with Asm, you'd probably want to use your favorite assembler to build the appvar rather than using Axe).

So this is what you have for now:
Code: [Select]
.FOXP
prgmSMASHH
38→°FoxGravity

[]→°FoxBEGIN
[01]
"SSBOCHAR"[00]
Data(°FoxEND-°FoxBEGIN^r)
[00000000000000000000000000000000000000000000000000000000]
"Fox"[00]

[]→°DB
Data(°FoxGravity)
Data(5)
Data(20)
Data(2)
Data(255^r)
Data(°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r)
Data(°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r)
Data(°FoxStand-°DB^r)
Data(°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r)
Data(°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r)
Data(°FoxStand-°DB^r)

[]→°FoxStand
##that state is not done yet but since you wrote its adress above, you need that adress to exist

[]→°FoxEND
## dont forget that the °FoxEND must be the last line of your program, it's not because you wrote it at a previous step that what you add at the next step must be written after it

We now have quick access to the Standing state... which we didn't implement. That's what we are going to do.


States

States have those fields:
2x2 bytes: pointer to sprite facing right, pointer to sprite facing left
2x1 bytes: teleportation (X,Y)
1x1 byte: flags
2x2 bytes: speed
1x1 byte: arrow key influence
1x2 bytes: adress to next state by default
<depends>: commands
1x1 byte: 0, end of commands.

- I guess there's no problem with the sprite pointers, except maybe the sprite format, which is just 1 byte for the width in bytes (width in pixels divided by 8) , one byte for the height in pixels, then usual data to describe pixels, 1 bit per pixel.
- Teleportation should be straightforward too. Basically, if you want your character to have its position changing when entering that state, put non zero numbers here. Notice that those numbers will obviously be added to your current position. And since they are 1 byte numbers, you can only move from -128 to +127. This is actually not implemented yet.
- Flags change the behaviour of your state.
--- °Inv when set will grant your character invincibility during that state (not implemented)
--- °Piv when set allows you to pivot (change the direction you're facing)
--- °AbsX when set will set your X speed to the specified X speed in the speed field, and when not set will add the X speed in that field to your current X speed
--- °AbsY is obviously the same for the Y speed
--- °SetKnockBack is unused
--- °GroundNull states that when in that state you are on the ground and can't use attacks
--- °GroundOK states that when in that state you are on the ground and can use attacks
--- °GroundDash states that when in that state you are on the ground and can use dash attacks
--- °AirNull states that when in that state you are in the air and can't use attacks
--- °AirOK states that when in that state you are in the air and can use attacks
--- °Aerial states that this state is an aerial attack (don't follow the example of the Fox I made, he doesn't use that flag when he should)
--- °Ledge states that you are currently holding a ledge
- Speed is the X speed and Y speed we mentionned when talking about °AbsX and °AbsY
- The arrow key influence is a number that, when non-zero, will allow your character to be moved horizontally during that state. It is for example used in the Air (falling) state but it may be set to zero in most attacks. The higher it is, the more the character can be moved of course.
- The adress to the next state by default is pretty straightforward too
- Commands (will) have their section below in that tutorial but are not used in the standing state so first read and understand the following example

The Standing state is a very simple example (plus, it's the state you gave the adress everywhere so it would rather be defined soon).
I am throwing it without more explanation because I don't know what to say, it you have questions, feel free to ask.

Code: [Select]
.FOXP
prgmSMASHH
38→°FoxGravity

[]→°FoxBEGIN
[01]
"SSBOCHAR"[00]
Data(°FoxEND-°FoxBEGIN^r)
[00000000000000000000000000000000000000000000000000000000]
"Fox"[00]

[]→°DB
Data(°FoxGravity)
Data(5)
Data(20)
Data(2)
Data(255^r)
Data(°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r)
Data(°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r)
Data(°FoxStand-°DB^r)
Data(°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r)
Data(°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r)
Data(°FoxStand-°DB^r)

[]->°FoxStand .état debout normal
Data(°FoxStandSprR-°DB^^r,°FoxStandSpr-°DB^^r) .sprite
Data(0,0) .téléportation
Data(°Piv+°GroundOK)
Data(0^^r,0^^r) .V
Data(0) .arrowkeys influence
Data(°FoxStand-°DB^^r) .état suivant par défaut
Data(0)

[021B]->°FoxStandSpr
[004000A001300208052407142834660EF1946FF821F4DCE2A4C794CF95C84E3863F037F80FFC0F3C0B1C079603DE01CE03DE039E010C]
[021B]->°FoxStandSprR
[020005000C80104024A028E02C147066298F1FF62F84473BE325F32913A91C720FC61FEC3FF03CF038D069E07BC073807BC079C03080]

[]→°FoxEND

Notice that flags can be added in the flags field. Writing "or" instead of "+" is advised however, in case you add twice the same flag (since or_ing  it twice gives the same result as or_ing it once) but "+" is more compact so I use it.

2
Super Smash Bros. Open / [Asm]How To make your own character
« on: September 30, 2014, 12:05:44 pm »
(Still in the works. You can start making your character but nothing guarantees that you'll never need to come back to what you've already written. Spriting doesn't have this kind of risk though. If you are really in an urge to make a character and can't wait for this to be done, you can also have a glance at Fox/Falco's source.)


Random Notes

I have no idea if Spasm can compile into appvars instead of compiling into programs so I actually compile as programs then convert into appvars. That's why I'll say "program" and "appvar" everywhere without distinction.

The Asm tutorial will probably take more time to write than the Axe tutorial since I have a character "done" in Axe but have yet to provide examples in Asm. At worst, read the Asm tutorial, then read the Axe tutorial, notice where the difference are, they are not many really (there's nothing high level in making characters and I don't even think there's anything high level in Axe anyway).


Notes to make your life easier

You can include the smashh.inc into your program. It only includes definitions, not code nor data so you can include it wherever you want in your program.
This will not only be a lot more readable for you to write "AirNull" than to write "%00000011" but this will also allow some specification changes (I hope that will never happen but we never know) because if you wrote "AirNull" everywhere, just change the include and the AirNull constant is changed everywhere while if you wrote "%00000011", you'll have to change them all "by hand".

I'd also advise you to use your own macros, like "#define Gravity 38" so that you can quickly change a constant everywhere in your program.


How do characters work, without details (you'll have details below)

Basically, they work with states. When your character is standing, doing nothing, it's in a state that we can call the "Standing state". It will leave this state when you press Jump for example, to go to the "Jumping state". Another example is the "Dashing State", that repeats itself (not entirely true) until you stop pressing the arrow key you pressed to start this state, or when you press Jump, etc.


The Header

This is necessary to have the game list your character and not list random appvars that don't have the right header.

The header starts with a one byte number, which for now is 1. This is actually not used for now, but in case specification changes happen (which I still hope will never happen), you'll have to put 2 here then 3, etc so that the program knows which specification your character is following.

You then need to put "SSBOCHAR",0. This is what the program uses to check if the appvar is a SSBO character or not.

The following two bytes are the size of the program.

Then, you put a 16x14 icon for the character selection menu (28 bytes).

You finish the header with the name of your character, obviously null-terminated.

For example if you are making Falco, here's what it should look like for now.
Code: [Select]
.org 0

.db 1
.db "SSBOCHAR",0
.dw HeaderEnd
.db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
.db "Falco",0

HeaderEnd:


General Information

After the header, you need to put information about your character that SSBO will needs to get quick access to. In that order:
1 byte: gravity (not used anymore, can be recycled for something else)
1 byte: air speed
1 byte: traction
1 byte: max number of jumps (2 in general, 5 for Jigglypuff)
2 bytes: max horizontal speed (not used yet)

Then follow the adresses of states that the program will need to have quick access to. A counter example is the second frame of the Down Aerial. You only access that one after the first frame. That first frame however needs to be quickly accessed to when the player asks for a Down Aerial.
All of those adresses take two bytes.
Since for now you have not written any state and have the adress of none, just put the adress of the standing state everywhere, you'll change that as you go along.

Anyway, in that order:
Standing, Airing, Dashing, GroundJump, AirJump, Landing
AirNeutralSpecial, AirSideSpecial, AirDownSpecial, AirUpSpecial
GroundNeutralSpecial, GroundSideSpecial, GroundDownSpecial, GroundUpSpecial
DashAttack
SideSmash, DownSmash, UpSmash
NeutralAir, ForwardAir, BackAir, DownAir, UpAir
LedgeGrabbed

Just a little precision. Axe compiles program "in" the RAM area it will be executed. For Asm users, I mean there is no way to say .org 0. However, state adresses need to be the ones related to the beginning of the data, not absolute ones assuming the program will be located at a precise location. This is why you'll have to put a "[]→°DB" right after the header and a "-°DB" after all your adresses.
Luckily for you, you're in the Asm tutorial so we'll use .org 0. Notice that we need another label at the very end of the data that we will add to HeaderEnd in the "size of data" field in the header.

So this is what you have for now:
Code: [Select]
#define FalcoGravity 38

.org 0

.db 1
.db "SSBOCHAR",0
.dw HeaderEnd+DataEnd
.db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
.db "Falco",0

HeaderEnd:

.org 0

;INFO ----------------------------

.db FalcoGravity
.db 5
.db 20
.db 2
.dw 255

.dw Stand
.dw Stand
.dw Stand
.dw Stand
.dw Stand
.dw Stand
.dw Stand
.dw Stand
.dw Stand
.dw Stand
.dw Stand
.dw Stand
.dw Stand
.dw Stand
.dw Stand
.dw Stand
.dw Stand
.dw Stand
.dw Stand
.dw Stand
.dw Stand
.dw Stand
.dw Stand
.dw Stand

Stand:
;nothing here for now

DataEnd:

## dont forget that the DataEnd must be the last line of your program, it's not because you wrote it at a previous step that what you add at the next step must be written after it

3
Super Smash Bros. Open / [Axe] Super Smash Bros. Open
« on: August 22, 2014, 07:20:43 am »
Finally, this project gets a topic ;D

So yeah, as some of you have already seen on IRC, I am working on a Super Smash Bros. Melee clone for monochrome z80 calcs. If you don't know that game, here's a link that may interest you.

Before annoying you with text, here's a screenshot of the current progress.


On that screenshot, you can only see one Fox moving. That's only because I don't want my left hand to play against my right hand but I checked, everything works with the other Fox too.
For now, they are played on the same calc (with different keys obviously) but for future versions, I was thinking about two solutions: either you use a second calculator as a pad without its screen being used or I use CalcNet as geekboy suggested. That's for future versions anyway, I have other problems to solve.

Now, why "Smash Bros. Open" ? Simply because of a play-on-words with "Open".
Those watching the tennis know that "Open" can refer to a competition, which fits a game such as Smash Bros. pretty well.
Those using Linux might think of open-source programs and other openness things.

To clarify that openness, let me give you an example. A question that I was often asked is "Will there be only Fox ?". And the answer is "Yes and no".
I will probably only make Fox. But the engine is really modular which (will) allow you to create your characters and play them ingame without even having access to the source code (they will be in appvars in other words). Even if you want to play as an invincible leek that one-shot with every hit !
As for the source code, it will probably be published (once cleaned up a bit) in order to allow people who want to add missing features (such as items) to do so.

Speaking of which, the source code is completely unoptimized, but it is done on purpose. This way, people who want to edit it can do so very easily instead of digging through my usual unreadable code (even though not necesarily more optimized :P ). In fact, the source code is currently 51092 bytes with comments and preproc constants, while the executable is not even 13000.

Another question people can wonder is "6MHz or 15MHz ?". And the answer is "both" for now.
What slows down the program most is drawing the map. So we can play at 15MHz with a "complicated" map, such as in the screenshot, or at 6MHz with a "simplistic" map that only contains rectangles. That's still a bit slower than the 15MHz version with the complicated map, but it is very playable in my opinion.

Credits
Badja for scaled sprite routine.
Matref for packing those routines into an axiom.
Quigibo and Runer112 for Axe.

Download
http://ti-pla.net/a110486

I think you'll easily guess the keys I use to control one of the Foxes. For the other one, the keys are the numpad, log and x2.

I don't see anything else to say for now so I'd say I'll answer questions if you have any ;D

4
General Calculator Help / Force TilEm to send to archive ?
« on: August 05, 2014, 10:47:28 am »
So I have two >10KB files I'd like to send to the emulator. The problem is that the sum of their sizes is over the amount of RAM. Obviously, I can and have to send them to archive. But how can I do that in command line with tilem ? For now I do "tilem2 file" and I don't see where I decide where I want my file to go.

5
I am trying to make a file to add support for syntax highlighting for Axe code in vim, and in the list of tokens I'd like to support is for example "[|a] [|b]".
However, when I try to open an "Axe file" with this syntax file, it says an error (can't tell exactly which error, I have two PCs, one with internet (this one) and the other one without (the one I am experiencing issues with vim)) about "a]" and "[", as if every "|" character broke the line or something and then what it saw was "[" followed with "a]" followed with "[".

So any idea what this character does ?
And most of all, any idea how I could get vim to highlight "[|a]" without getting an error when opening my files ?

6
General Calculator Help / Development Environment for z80 on Linux ?
« on: July 23, 2014, 05:37:30 am »
So, as the title says, I am looking for something that would allow me to code in Axe (or in Basic if you prefer) on Linux.

Basically, I need something like TokenIDE (not necessarily with as many options like image editing and such, just something to edit 8xp files, or convert txt files into 8xp files) and something like Wabbitemu (same, I don't necessarily need an interface with keys, just something with a screen that I can transfer 8xp files to).

Absolute requirement: offline. SourceCoder and jsTIfied are not an option for example.

So, any idea ?

(note that "TokenIDE running with mono" can be an option if it works, I didn't try yet in case people have a better solution).

7
Minecraft Discussion / Minecraft or Minetest ?
« on: July 10, 2014, 01:26:48 pm »
Well what the topic title and the poll title say. I know that a lot of people play Minecraft but I wanted to know how many play Minetest in comparison because
  • Minetest is free, Minecraft isn't
  • Minetest runs on my netbook, Minecraft doesn't
  • I need now to compare the communities to help me make a choice :P

So do you play any of both, or both ?

edit
Also, if you have any argument for one of them, please share ;)

8
TI Z80 / Yet another late 2048 clone
« on: June 19, 2014, 04:12:05 pm »
Basically, I wanted a 2048 that was as fast as nikitouzz's (or at least with a constant speed) and as beautiful as JWinslow's, but I can't understand anything in JWinslow's code o.o

So here's mine. It lacks a lot of features (like score saving for example) but it's not bad for something made in one day :P
2705 bytes when compiled for Ion.

Plus, Streetwalrus is going to be happy since I plan on adding an undo button :P

edit yeah, those are the same graphics as in JWinslow's version and I have the permission to use them as I was the author and gave them to JWinslow :P

9
TI-Nspire / [Ndless] Jetpack Impossible
« on: May 15, 2014, 05:13:20 am »
Yeah, it's written "Hayleia" on the left and you are in the Nspire board, you are not hallucinating.

So, here's my first real Nspire project. Jetpack Impossible, based on the game on smartdevices.

Your goal is to help the astronaut get a lot of gems before dying from hitting a meteorite (why do you need a scenario ? just play). You have a Jetpack with only two buttons: up-left and up-right. You'll have to rely on gravity to go down (yeah, gravity when there's nothing beneath you is completely logical, especially when meteorites are not affected by it). Note that you are invincible as long as you didn't pick up any gem (who wants to play the 7 illogical things game ?) and you edgewrap (I wanted to say it in one word, I don't know if that's correct and understandable).

One animated screenshot is better worth than >9000 words so here's one.


To do
-highscore saving
-displaying score and medal after dying ?
-a menu ? (what for ?)

By the way, I thank pierrotdu18 for his Flappy Bird source code from which I learnt a lot about nSDL, Lepzulnag for his work on nSDL fonts and of course Hoffa for nSDL and Extended and the others for Ndless.

Download: http://ti-pla.net/a59790

10
Gaming Discussion / Anyone playing Project M ?
« on: April 30, 2014, 02:12:54 am »
Note, this is not a calc related sub forum, so I am not talking about calc84maniac's Mario game, but the community Super Smash Bros game :P

So I noticed there were some Smash fans here and since I just installed Project M on my computer and I was wondering if there were people here playing it too, so maybe we will be able to Netplay sometimes a bit (during Summer, not now, I have a lot of school projects -.-).

Just for those who don't know, Project M is basically Melee with Brawl graphics, or Brawl with Melee gameplay, see it the way you want :P

11
TI Z80 / Flappy Bird - Hayleia
« on: February 18, 2014, 04:00:38 pm »
Many people already made their version of a Flappy Bird clone. So I thought "why not me too ?" :P
I think it is useless for me to explain the gameplay, it's in every other topic. So I guess it's just screenshot time (6MHz, as usual).


As you can see, collision detection is missing and the game needs a menu and such things so no release for now. I'd also like to optimize it a bit so you'll have to wait :P
Anyways, tell me what you think of it :)

Download here

12
Axe / How to rename an appvar (without copying into new and deleting old)
« on: January 29, 2014, 02:53:18 pm »
Say I have to edit an appvar.

I can do that:
Unarchive it.
Edit it.
Archive it.


The problem with that is that I can lose all my progress if a RAM Clear occurs for some reason (like battery dead).

So I would like to do that:
Copy appvar to temporary one.
Edit temporary appvar.
Delete original.
Rename temporary with original name.

Archive renamed appvar.

So how do I rename an appvar (that is in RAM if that helps) ?

13
WabbitStudio Software Suite / CSE support for Wabbitemu ?
« on: January 16, 2014, 06:22:15 am »
The title sums it all. I don't know if you were already asked (and I would be surprised if you weren't) but I didn't see that question anywhere.
So would you consider adding CSE support for Wabbitemu ?

(And I know there is jsTIfied, but I hate online solutions, I spend 6 hours per week in a train and "online" can't be part of a solution).

14
TI Z80 / AudaciTI - 4 channel music player and editor (in the works)
« on: January 02, 2014, 02:33:33 pm »
Latest Update: http://ourl.ca/20419/372776

First of all, AudaciTI is a play-on-words because it sounds like Audacity... when said in French, so if you have a better name (preferably not longer than 8 chars), I might take it.

Why another music player ?
Because, from what I understood, TruSound takes "too much memory" (not too much for what it plays, but too much to fit a lot of music in a calc) and runs at 15 MHz. MuseInc needs both Axe and Celtic III on the calc so it doesn't fit either on a regular 83+, same for MobileTunes which requires DoorsCS (well it fits but takes a lot of memory), TI JukeBox only plays one channel of sound, ...
(I didn't know about this one until fb39ca4 told me about it, which was after I posted).

So this is why I thought we needed a player with those features:
  • plays 4 channels of sound
  • runs at 6 MHz
  • has an on-calc editor
  • has a on-PC editor (I won't do that but the format I'll use will be so easy anyone who knows how to code for PC could do that editor)
  • standalone (no need for librairies)

Do you have some progress to show off ?
Yay ! Screenshot Time !
Seriously, I won't do a screenshot for a music player. But yeah, I have an executable if you want. Plays a stupid track with 8x4 notes in. If you don't have the adapter, you can always try that with Wabbitemu. The other executable (TESTNOTE) is to test notes independantly (no chord, one note at a time).
The "player" (if we can call that demo a player) supports 45 different notes for now, but I was too lazy to make a music that supports all those notes without an editor. But you can still hear most of the range in the demo, it plays the 6th note in the list and the 42th note.



Now it's my turn to ask questions ! :P

Do you think the sound you heard in that demo is crappy ?
Do you think we need such a player-editor or do we already have enough of those ?



Some documentation in spoiler, if you want to make an editor.
Spoiler For Spoiler:
The first note that my "player" supports is a F#. So whenever you want to play that F# you put 0. Then, this is not logic but you go decreasing, so the "next" note is the previous note, so a F. So whenever you want to play that F, you put 1.
Of course, it doesn't support only one F#, so 12 is also a F# (lower than the 0 one), 24 too, same for 36,... but not 48 because the player only supports 46 notes (from 0 to 45).

The first note that my player supports is a A. So whenever you want to play that A you put 0. Then the next note is obviously A#, so whenever you want to play it you put 1. And caetera until you reach 45 which is the last note my player supports.

The player reads from appvars, and you don't want to play zStart's appvar so put "AUDACITI"[00] at the beginning of your appvar.

Now that you know which note corresponds to which number, how do I play them ?
I'll make the player support more things but for now, you just put note11, note12, note13, note14, note21, note22, note23,note24,... where note1X are the components of the first chord, note2X are the component of the second chord, ... and noteX1 are played on the first channel, noteX2 are played on the second channel, ...
And you end with a 255.

So the thing you hear in the demo is just that:
   "AUDACITI"[00]
   Data( 45-18, 45-42, 45-30, 45-06 ) .do  do  do  do
   Data( 45-19, 45-40, 45-26, 45-09 ) .si  re  mi  la
   Data( 45-21, 45-38, 45-28, 45-07 ) .la  mi  re  si
   Data( 45-23, 45-37, 45-25, 45-11 ) .sol fa  fa  sol
   Data( 45-25, 45-35, 45-26, 45-09 ) .fa  sol mi  la
   Data( 45-26, 45-33, 45-23, 45-13 ) .mi  la  sol fa
   Data( 45-28, 45-31, 45-23, 45-11 ) .re  si  sol sol
   Data( 45-30, 45-30, 45-23, 45-11 ) .do  do  sol sol
   Data( 255)

(sorry for the "45-X", this is due to a previous way of storing notes).

Planned:
-change the length of notes
-silences
-change the position of channels
-mute channels (to save space when only one note at a time is played)
-"drums"

15
Computer Usage and Setup Help / [shell] Get last part of a string ?
« on: December 07, 2013, 11:54:46 am »
First of all, what does "last part" mean ? It means "all characters after some special character". For example, if that character is "-", then the "last part" of "1574-114687-415" is "415" and the "last part" of "jg7e;f,k-e" is "e".

So, yeah, how do I extract the "last part" of a string (you can provide examples with the "-") ?

edit that's surely not informative, but I am using Ubuntu 13.04

Pages: [1] 2 3 4