Danmakufu

http://www.megaupload.com/?d=TMU80ABN

Danmakufu scripting is only as easy/complicated as you want your script to be. A more complex attack will require more effort and time than simply firing a bullet every few seconds, as demonstrated by my Maked Man script. It didn't actually take that long, and most of the concepts demonstrated by it are pretty simple after you get the hang of it.

Enough chattering, on to the script!

Anyways, these are the basic guts of a Danmakufu script:

Code:

#TouhouDanmakufu
#Title[Attack Name]
#Text[Attack Description]
#Image[.\img.png]
#BackGround[User(.\bg.png, 1, 1)]
#BGM[.\bgm.mp3]
#PlayLevel[Normal]
#Player[FREE]
#ScriptVersion[2]

script_enemy_main {
    @Initialize {
    }

    @MainLoop {
    }

    @DrawLoop {
    }

    @Finalize {
    }

    @BackGround {
    }
}

"TouhouDanmakufu" specifies that it is a Danmakufu script. Leaving it blank will specify it to be a single attack. You can also create other scripts with it placing "[Plural]", "[Stage]", and "[Player]" at the end.
The title and description are self-explanatory, they're the title and description of your script.
Image is the image displayed to the right of the description. 192 by 224 seems to be a good resolution for these.
Background is the in-game background image. There are two preset ones: Default and IceMountain. You can also use user-specified backgrounds by specifying the image, and the X and Y scrolling speeds. Never really tried this one out. Just leave it out for now.
The BGM is the background music, for those of you who couldn't tell from the abbreviation. This can be overwritten by the "PlayMusic" command, so it's very good if you're creating a stage with a boss included, or if you're simply using more than one song.
PlayLevel is the difficulty displayed on the side. Not much more to it than that.
Player specifies what characters are playable. Such as the default Reimu and Marisa characters. Just type in "REIMU" or "MARISA" to rescrict access for every character besides Reimu/Marisa A and B. For user-created players, just type in the directory of the player script of the character you want to include.
The script version specifies which version of Danmakufu it is. Now, I used to not know what this was, so I left it at two. But now with the release of the new Danmakufu alpha, I realized that different script versions are compatible with different versions of Danmakufu, three being the latest. Since there is no working version of Danmakufu 3 yet, I'd suggest we stick to scripting with Danmakufu 2.
Now on to the heart of the Danmakufu script!

@Initialize is used mainly for stuff that only occurs once, usually at the beginning. Things included are setting the boss life(IMPORTANT!), timer, and other stuff.

@MainLoop is... Well, the main loop function. This is can be used for whatever you desire, but we'll stick with bullets for now.

@DrawLoop is used for drawing graphics, such as the boss graphic.

@Finalize is stuff triggered after the script is finished. Such as dropping point items, and other death-related stuff.

@Background is optional, but you can use this to draw backgrounds and/or background effects.

Alright, then!
Now that we're done explaining things, let's get down to business!

Anyways, now that we've gone over the basics, then we should probably go over firing some bullets soon.
Feel free to copy the blank script in the last one if you need a template.

First off, let's go over the functions:

CreateShot01 is the simplest to operate. The arguments for this are, in order; X spawn point, Y spawn point, speed, angle, graphic, and delay. So CreateShot01(GetX, GetY, 3, 90, BLUE32, 30); would fire a moderately fast blue knife bullet straight down with a half-second delay.

CreateShot11 is the same as the last, but a bit more complicated movement-wise. The arguments for this are, in order; X spawn point, Y spawn point, X speed, Y speed, graphic, and delay. So CreateShot11(GetX, GetY, 1, 3, GREEN02, 0); would fire a medium green bullet that goes diagonally downward and a bit to the right with no delay.

CreateShot02 is, without over-complicating things, an upgraded CreateShot01. The arguments for this are, in order; X spawn point, Y spawn point, speed, angle, acceleration/deceleration speed, maximum/minimum speed, graphic, and delay. So CreateShot02(GetX, GetY, 11, 90, -0.158, 0, RED03, 30); would fire a large red bullet that starts fast, stopping right before the player gets hit.

CreateShot12 is an upgraded CreateShot11, in the same way that CreateShot02 is an upgraded CreateShot01. The arguments for this are, in order; X spawn point, Y spawn point, starting x velocity, starting y velocity, x acceleration/deceleration, y acceleration/deceleration, max/min x speed, max/min y speed, graphics, and delay. So CreateShot12(GetX, GetY, 5, 5, -0.3, 0, -5, 5, AQUA22, 0); will create a bright blue butterfly bullet(try sayin' that five times fast.) that starts downward and to the right, but curves to the left, maintaining a semi-fast downward velocity.

And finally, my favorite to use, CreateShotA! This one requires a lot of explaining, so listen up!

CreateShotA uses 3 commands: CreateShotA, SetShotDataA, and FireShot.
CreateShotA assigns the bullet ID, spawn point, and delay. So CreateShotA(1, GetX, GetY, 60); would create a bullet with the ID of 1, and tell it to spawn at the enemy's position, with a 1 second delay.
SetShotDataA sets the bullet's attributes, and can be called several times for complex bullet behavior. The arguments for this are, in order; bullet ID, frames until SetShotDataA is applied, speed, angle, turn, acceleration/deceleration, maximum/minimum speed, and graphic. (Remember, the delay is called in CreateShotA!) So SetShotDataA(1, 0, 0, 90, 0, 0, 0, WHITE31); and SetShotDataA(1, 60, 0, 90, 0.1, 0.08, 3, RED31); would tell the bullet with an ID of 1 to appear as a white kunai bullet and stay still for 1 second, and then turn red and begin accelerating until reaching a speed of 3, while turning right.
SetShotDataA_XY works the same way as CreateShot11 and 12. Instead of an
SetShotKillTime tells the game how long to keep the bullet onscreen. The arguments for this are, in order; bullet ID and frames alive. So SetShotKillTime(1, 240); would tell the bullet with the ID of one to delete itself after 4 seconds.
Finally, FireShot is used to fire these shots. So FireShot(1); would fire the bullet with an ID of 1.

But after all this, our script still doesn't work right!
That's because we have to establish a way to keep track of the frame that Danmakufu is on.
There's an easy way to do this with two things; variables and statements.

Variables can be established anywhere, but outside of the script headers, at the beginning of script_enemy_main, before @Initialize is usually where I establish them. I like to have global variables that can apply to the whole script, instead of having them in just one space. But there is an advantage to having area-specific variables as well.
This is done by using "let variable = something;", with "something" being whatever your variable to represent. It can be a number, a function, or a path to a file.
And your variable can be anything, as long it's not the name of an existing function/variable or a number.
We'll name our variable frame, to keep track of the frame Danmakufu is on, and it will equal 0. So call "let frame = 0;"(Semicolons are key!), and "frame" now represents the number 0. Still keeping up with me?

Now, in @MainLoop, we must create a statement.
Statements are simply telling the game to do something after a certain amount of conditions are all met.
This will activate when the condition is met, for however many frames the condition is met.
So if we tell the game "if(GetTimer==20){do something}", then the game will do something when the timer is equal to 20.
This is perfect for our frame-keeping mechanism.
We can tell the game "if(frame==60){fire bullets}", so the game will fire our bullets after 1 second. Right?
Not quite. "Frame" won't be able to do anything unless we tell the game to make frame progress a the same rate the game does.
Thankfully, we can add and subtract from variables.
So if we place "frame++;" in our @MainLoop, it will add 1 to the variable "frame" every frame. So after 60 frames, or one second, our bullet will fire. Great, we're done!
Well, not yet. We must reset frame to zero after it's reached 60, or else it will only fire one bullet.
So in our statement, we can tell frame to reset to zero by saying "frame = 0;".
And now we're done! Finally...
Now go forth and create your own danmaku!

No good script is complete without some sort of movement, so let's get to it!

Well, the most I can really do is explain the movement functions.
SetMovePosition01 is one of the most simple types of movement functions. Simply specify the X, Y, and speed, and your character will move to the destination at a set speed.
SetMovePosition02 works the same as the last one, except instead of defining the speed, you're defining how many frames the movement will take. 60 frames being 1 second, 120 being 2, etc.
SetMovePosition03 is the best one for standard movement, in my opinion. The movement for this compared to the other two is so much smoother. The arguments for this one are, in order: X destination, Y destination, weight, and max speed. The weight is like the speed at which the enemy stops. 10 is a good default speed for this, but you're welcome to experiment with this as much as you like.
SetMovePositionHermite is a complicated concept, but I'll try to explain this as best as I can. As with all movements, the enemy will move to the given point at a specified speed. Except for instead moving straight, it draws a curve from the current point to the destination. The arguments in order are: X destination, Y destination, distance from curve to start, starting angle, distance from curve to destination, end angle, and frames. For the distance, I usually leave it at 300 for a moderately sized smooth curve. But again, you're welcome to experiment and see what you can come up with.
SetMovePositionRandom01 is also a lot to explain, so listen well. Think of this as drawing a box. The enemy will find a random position inside the specified box, and move to it. This one works just like SetMovePosition01, of course. But you have to specify the boundaries for the area after the speed starting with left, top, right, and then bottom.

Some other handy functions involving placement are SetX and SetY, which are self-explanatory; they set the enemy's X and Y position.

Now that I've explained movement functions, you should start by experimenting and creating your own movement patterns.

Well, by now you might be wondering how to get your boss to appear onscreen. Let's go over that, shall we?

First off, we need an image. You can find your own, or you can download this picture of Reimu just to test.



Now, be careful with this. You shouldn't use this for fan works to be distributed.
I'm not saying it like it's a crime or anything, because it isn't. But sometimes it'll just get you a big thumbs down.
You should try to use your own graphics/music, but not everyone is artistically inclined.
Again, you're still allowed to use ZUN graphics freely, just try to be careful about it.

With that said, let's get to drawing.

I'm just going to explain this little really quickly, so bear with me. Notice the transparent parts? Well, not everyone has access to fancy programs like Photoshop and GIMP. So for those of you who don't, you may use the color black instead. But make sure you avoid using black in your graphics, because they will come up as transparent in-game, as well. Try setting the color to something near dark, like #000001. Note that since it's not completely black(#000000), it will show up as black in-game.

Anyways, back to the script.
First off, I declare a variable to lead to the image. This part is purely optional, but saves a lot of typing. You're still familiar with variables, right?
Anyways, just call something like "image" or "reimu" and let it equal the path to your image. Something like this:

let reimu = GetCurrentScriptDirectory ~ "path to your image\image.png";

Note how I used "GetCurrentScriptDirectory" before the path. That lets it start looking in the current directory of the script you're running, instead of starting in the "th_dnh" folder. The tilde(~) is necessary, so don't forget it. Also, try to make your image a PNG file. Danmakufu prefers the PNG.

First off, you're going to need to load your graphic. This is done with LoadGraphic. The only argument is the path to the image, so specify that and you're all set.
LoadGraphic(reimu); will successfully load our picture into Danmakufu.
Next, you'll need to set the texture for the boss. Done with SetTexture, in the same way that LoadGraphic works.
Now, there are several functions related to drawing, but I'll go over the most important one first: SetGraphicRect.
Think back to the movement tutorial. This works the exact same way. It's like you're drawing a box over your image for the game to use. Again, the arguments for this are left, top, right, and bottom coordinates. So SetGraphicRect(0, 0, 64, 64) would start from the top left and create a box 64 pixels by 64 pixels. Perfect for our Reimu sprite.
Finally, the last thing to do is draw our sprite. Done with DrawGraphic(x, y), you can choose to draw the graphic wherever. But since it is for our boss, let's use GetX and GetY. This'll draw the graphic wherever the boss moves, so it'll move along with the boss.

I'll explain the rest of the functions later, but for now, use this knowledge to get your boss to appear on screen.

Alright, so I've explained enough MainLoop. I'll start explaining a method that is much easier, but can sometimes be a pain to work with.

Tasks are like creating your own functions: using already existing functions, that is. Tasks are created just like this:

task TaskName{
do stuff
}

And that's it.
Tasks can be called inside other tasks as well, as long as the previously mentioned task isn't already being called.

So let's create a simple boss. First off, let's create two tasks for movement: "Move" and "Fire".

Code:

task Move{
    SetMovePositionRandom01(50, 30, 10, GetClipMinX+50, GetClipMinY+50, GetClipMaxX-50, GetCenterY-50);
    }

Code:

task Fire{
    CreateShot01(GetX, GetY, 3, 90, RED01, 30);
    }

Code:

function wait(frames){
    loop(frames){yield;}
}

The wait function is important, as it tells Danmakufu to wait a certain amount of frames until moving on by looping the yield task.
Anywho, the task Move will move the boss to a random position. And the Fire task will fire a red bullet straight downward. Simple, isn't it?
Now to mesh these all together, we'll create a looping task that'll start the sequence. Again, very easy. Just like this:

Code:

task Start{
    loop{
        Move;
        wait(60);
        Fire;
        wait(60);
    }
}

By calling the start task in initialize, the boss will move, wait one second, fire a bullet, and then wait another second before moving again, looping the task endlessly until the timer runs out(assuming you've done that) or until the boss dies.

A few more things: like everything else in Danmakufu, tasks and functions are CASE-SENSITIVE. "Derp", "derp", and "DERP" would all be recognized as different tasks.

Also, look back to the wait function. Note the word "frames" in parentheses? You can create tasks/functions with variables instead of numbers that can be defined later. Just place the variables in parentheses after the task name, and define them when calling the task. This is great with bullet/laser/movement/whatever functions, as you can use them however the hell you want.

That's as much as I can explain; I hope this helps you and isn't just me over-explaining things again. x_x
I'm going to bed, more tutorials on the way soon.

So now that we've gone over tasks, this would be a good time to explain object bullets.

Object bullets are like breaking down CreateShotA and building a better bullet out of it: You can do more with these than any other kind of built-in function. You can manipulate these babies like no tomorrow. Stuff such as homing bullets, reflecting bullets, and pretty much everything ranging from Ripples of 495 Years to Icicle Fall -easy- and everything else.

So, in this case, we'll be doing an "easy modo" version of Ripples of 495 Years. Q.E.D "Ripples of 495 Years" consists of large loops of bullets being spawned from the boss, reflecting from the sides and exiting to the bottom. So we'll basically be doing that, except with less bullets.

First off, we'll need to create a task that can be called to spawned to create a bullet that can be reflected off of the walls. If you don't know how to create tasks, check the previous tutorial. If you DO know, however, kudos to you. Create one with a good name, such as "Shot" or "ReflectBullet"(my recommended ;3) and we'll start work on it right away.

Code:

task ReflectBullet{

}

It should look like that right now. Nothing in it, obviously. Should we fix that? Obviously.

First off, we'll introduce the creation process used to make object bullets. Obj_Create is used to create objects, including bullets, lasers, and special effects. For now, we'll stick to object bullets, so we'll used Obj_Create(OBJ_SHOT). Danmakufu is still case-sensitive, so make sure you have it capitalized just like that! Also, when creating an object bullet, it's best to assign it to a variable, since you'll be calling it when assigning its attributes, such as spawning point, speed, angle, and all the crazy things you want it to do.
Just to bring things up to speed, this is what we have so far:

Code:

task ReflectBullet{

let obj = Obj_Create(OBJ_SHOT);

}

Not too much progress, right? Well, it's still progress, so don't complain. Anyways, on to the actual creation!
There are several functions needed to get this bullet up and running, so we'll write them down now.

Code:

task ReflectBullet(x, y, v, angle, graphic, delay){

let obj = Obj_Create(OBJ_SHOT);

Obj_SetPosition(obj, x, y);
Obj_SetSpeed(obj, v);
Obj_SetAngle(obj, angle);
Obj_SetAutoDelete(obj, true);
ObjShot_SetGraphic(obj, graphic);
ObjShot_SetDelay(obj, delay);

}

Notice that we used variables that are left undefined. That's where the parentheses in the task name come in. The variables can be defined when the task is called, instead of having to define them in the task. Now, our bullet is finished, but it doesn't do anything too special. This is where things get technical, so listen up!
Now that we've got our specifics, we'll make it reflect. Add this to the bottom of your new code:

Code:

while(!Obj_BeDeleted(obj)){
    yield;
}

The yield command is very important, and pretty much keeps this bullet functioning. Basically, it tells the program to stop the task being run and check if there is any other code to perform. In non technical terms, though, it keeps Danmakufu from crashing and burning 9/10 times, so make sure you don't forget it! And finally, the reflecting part! Now, we'll want this to reflect once it meets the sides of the screen, because bullets bouncing out of nowhere is just silly.

Code:

if(Obj_GetX(obj)<GetClipMinX){

}

This will tell Danmakufu that if the bullet is not yet deleted, and the object's X position is less than GetClipMinX, which is the minimum x that the player can go, to reflect. And now, we'll finally get to the actual reflection!
First off, we have to set the direction to make it look as if it's been reflected. So we'll use Obj_SetAngle again to do this. There's a little technicalities, but don't get confused; it's very simple! Just copy down these:

Code:

Obj_SetX(obj, Obj_GetX(obj) + 1);
Obj_SetAngle(obj, 180 - Obj_GetAngle(obj));

Obj_SetAngle will change it to look like it's reflected off the walls, and Obj_SetX makes it so that it actually "reflects"; if you didn't have this, it would just roll off of the walls or stick to them!

Now repeat this with the other sides, making changes as necessary, such as:

Code:

if(Obj_GetX(obj)>GetClipMaxX){
    Obj_SetX(obj, Obj_GetX(obj) - 1);
    Obj_SetAngle(obj, 180 - Obj_GetAngle(obj));
}

or

Code:

if(Obj_GetX(obj)<GetClipMinY){
    Obj_SetY(obj, Obj_GetY(obj) + 1);
    Obj_SetAngle(obj, 180 - Obj_GetAngle(obj));
}

Now, these will reflect to infinity if we don't establish some sort of way to keep track of how many times it's reflected, so in the same manner that we keep track frames, we'll make it so that it reflects once.

Code:

task ReflectBullet(x, y, v, angle, graphic, delay){
      let reflected = 0;
      let obj=Obj_Create(OBJ_SHOT);

      Obj_SetPosition(obj, x, y);
      Obj_SetAngle(obj, angle);
      Obj_SetSpeed(obj, v);
      ObjShot_SetGraphic(obj, graphic);
      ObjShot_SetDelay(obj, delay);
      while(!Obj_BeDeleted(obj)) {
         if(Obj_GetX(obj)<GetClipMinX && reflected==0){
            Obj_SetAngle(obj, 180 - Obj_GetAngle(obj));
            Obj_SetX(obj, Obj_GetX(obj) + 1);
            reflected++;
         }
         if(Obj_GetX(obj)>GetClipMaxX && reflected==0){
            Obj_SetAngle(obj, 180 - Obj_GetAngle(obj));
            Obj_SetX(obj, Obj_GetX(obj) - 1);
            reflected++;
         }
         if(Obj_GetY(obj)>GetClipMaxY && reflected==0){
            Obj_SetAngle(obj, -Obj_GetAngle(obj));
            Obj_SetY(obj, Obj_GetY(obj) - 1);
            reflected++;
         }
         if(Obj_GetY(obj)<GetClipMinY && reflected==0){
            Obj_SetAngle(obj, -Obj_GetAngle(obj));
            Obj_SetY(obj, Obj_GetY(obj) + 1);
            reflected++;
         }
         yield;
      }
   }

Once the bullet is reflected, the variable reflected will increase by one. And the requirements have been changed so that the bullet reflects only if reflected is 0.

One more vital piece of information: make sure you have a yield in your @MainLoop. If not, the bullet won't reflect off the walls.

Run this, and your bullets should be bouncing perfectly! And now that you know how it's done, experiment in other ways to make your bullets do anything!