[Danmakufu] Tuto :p

Suite a mon précédent post sur une Flandre que j'ai tenté de faire a partir de Danmakufu (https://touhou-france.forumactif.com/coin-des-artistes-f8/danmakufu-flandre-pour-les-nuls-p-t163.htm) je vais donc tenter de faire un petit tuto pour apprendre a se servir de ce logiciel :)

TÉLÉCHARGEMENT (LÉGÈREMENT OBLIGATOIRE)

Pour commencer, il vous faudra télécharger Danmakufu (normal) sur le site : http://www.geocities.co.jp/SiliconValley-Oakland/9951/products/th_dnh.html
Vous cliquez sur "東方弾幕風 v0.12m(約4000kB)" et vous pouvez commencer le téléchargement ;)

Pour faire fonctionner Danmakufu sur XP, vous aurez besoin de AppLocal (et accessoirement avoir installer les fonts japonaise sur vous ordi).
Sans AppLocal, vous serez en mesure de lancer Danmakufu, mais dés que vous lancerez une partie, ce sera le crash ^^
Si vous n'arrivez pas a le trouver, voici celui que j'utilise : AppLocal

Bref, quand vous lancerez Danmakufu, vous ne remarquerez aucune option pour créer des patterns, c'est normal, tout se fait a la main a coup de Bloc note !
Donc dans un premier temps, il vous faudra aller dans le dossier de Danmakufu (th_dnh) dans lequel vous trouverez un dossier Script, vous l'ouvrez, et ensuite vous allez créer votre propre dossier !
Nous y sommes, on peut commencer :)

COMMENCEMENT

Commencez par créer un fichier texte, et collez ceci :

Code:


#TouhouDanmakufu
#Title[]
#Text[]
#Image[]
#Player[FREE]
#ScriptVersion[2]

script_enemy_main
{    
   @Initialize
   {
   }
   
   @MainLoop
   {
   }
   
   @Finalize
   {
   }
   
   @DrawLoop
   {
   }
}

Le gros bloc du haut commençant avec un # permettent a Danmakufu de savoir sur quoi il travail.
Vous avez 2 champs a remplir maintenant ! #Title[], #Text[] (#Image[] est optionnel, vous n'êtes pas obligé d'y toucher pour que ça marche).
Quand je dit remplir, c'est écrire entre les 2 crochets ;)

Voilà, dés a présent vous pourrez lancer Danmakufu pour vous rendre compte que votre pattern peut être lancer ! Mais vus qu'il est vide, la partie sera relativement courte :)

On va donc modifier le fichier texte comme il se doit pour rajouter les éléments qu'il faut pour commencer son propre pattern :)

INSÉRER LE BOSS

Vous voyez le gros bloc script_enemy_main ? Celui qui avale les autres bloc avec ses accolades ouvrante / fermante (l'ouvrante se trouve juste en dessous de script_enemy_main, et la fermante a la fin), c'est le bloc qui va vous permettre de déclarer votre boss ;) et pour cela, il a besoin d'autres bloc pour fonctionner, @Initialize, @MainLoop, @Finalize et @DrawLoop.

Dans un premier temps, nous allons faire apparaitre un boss quand même :) Par défaut, Danmakufu possède les sprites de EX-Rumia que nous allons utiliser (une fois que vous aurez compris comment faire vous serez capable d'utiliser n'importe quel sprite !).

Dans le bloc script_enemy_main, vous allez coller au dessus de @Initialize la ligne suivante :

Code:

 let imgEnemy="script\ExRumia\img\ExRumia.png";

J'explique ce que cette ligne fait :

let : permet de déclarer la création d'une variable, ici imgEnemy

imgEnemy="script\Ex... : ceci permet d'initialiser imgEnemy avec la valeur se trouvant a droite du signe égal ( = ), la valeur se trouve être un fichier image se trouvant dans le dossier script\ExRumia\img\ et dont le nom est ExRumia.png

Très important de le remarquer, chaque ligne se termine par un point virgule ( ; ) ! Cela permet au compilateur que votre ligne actuel est terminé.
Dans certain cas on peut se passer du ; mais ces cas là sont suffisamment rare qu'il vaut mieux ne pas s'y intéresser ;)

Bref, voilà, vous avez déclarer l'image du boss ! Il va falloir maintenant le charger dans le pattern !
Dans le bloc @Initialize vous allez donc coller ceci :

Code:

LoadGraphic(imgEnemy);

Dans le bloc @Drawloop vous collerez ceci :

Code:

            SetColor(255,255,255);
            SetRenderState(ALPHA);
            SetTexture(imgEnemy);
            SetGraphicRect(64,1,127,64);
            DrawGraphic(GetX,GetY);


Et dans le bloc @Finalize vous collerez ceci :

Code:

      DeleteGraphic(imgEnemy);

Vous remarquerez sans doute que dans les lignes LoadGraphic(imgEnemy); ou encore SetTexture(imgEnemy); on retrouve ce imgEnemy déclarer plus haut ;)

Voilà ! Le boss a était déclarer et affiché sur le pattern ! Mais la partie sera toujours très courte ;) Il va donc falloir déclarer les règles de la partie !
Les règles de la partie se modifient depuis le bloc @Initialize dans lequel vous allez rajouter :

Code:

            SetLife(1500);
            SetTimer(60);
            SetInvincibility(30);
            SetMovePosition02(GetCenterX, GetCenterY - 100, 120);

Qu'es ce qui a était fait a l'instant ?
SetLife(1500); a eu pour effet de dire que votre boss a 1500 points de vie !
SetTimer(60); a eu pour effet de dire que votre boss durera maximum 60secondes !
SetInvincibility(30); a eu pour effet de dire que votre boss sera invincible pendant une durée de 30 frames (vous verrez par la suite, 30 frame c'est TRES rapide)
SetMovePosition02(GetCenterX, GetCenterY - 100, 120); a eu pour effet de positionner le boss là où les 3/4 des boss se placent.

Ensuite, allez dans @MainLoop et collez y ces deux dernieres lignes :

Code:

          SetCollisionA(GetX, GetY, 32);
        SetCollisionB(GetX, GetY, 16);

Maintenant, si vous lancez votre boss, vous serrez en principe capable d'aller lui exploser la tronche, mais comme je-ne-sais-plus-qui a dit : Le bois ne rend pas les coups !

En effet, nous avons donner une apparence au boss et ses règles de jeu, mais on n'a toujours pas commencer a créer son pattern !

Qu'es ce qu'on attend ? On y va donc :)

CRÉATION DU PATTERN - NOTRE PREMIER TIR !

Sans doute la partie la plus compliqué de tout ce bazar !
Bon on se lance avec le basique de chez basique !
Commencez a déclarer une variable de comptage de frame (juste en dessous de la ligne où vous aurez déclarer votre boss :D Juste au dessus de @Initialize)

Code:

let count=-110;

Donc, je déclare ma variable count comme étant égale a -110.
Pourquoi un chiffre négatif ? Parce que si vous mettez 0, le boss commencera dés le début a envoyer la purée, lorsque vous enchainez plusieurs SP, ça peut être moche que le boss n'attende pas la fin de sa dernier carte pour envoyer la prochaine.

Direction @MainLoop !

Code:

if(count==0)
{
            CreateShot01(GetX , GetY , 1, 90, BLUE01, 0);
}

Donc là j'explique ! J'ai créer un bloc de condition "if". "if" qui pourrais être remplacer par "si" en français ;) donc ma condition ici signifie que ma variable count devra être égale a 0 (bien respecter le double égale pour le test de condition surtout ! Si vous en mettez qu'un seul, vous insérerez 0 dans count ! Ce qui n'est pas du tout l'intention ;)) pour exécuter ce qui se trouve dans mon bloc "if", ce qui se trouve être une commande pour créer un tir !
Décortiquons cette fonction de tir !

CreateShot01(GetX , GetY , 1, 90, BLUE01, 0);
Cette fonction demande 6 arguments, chacun sont délimité par une virgule ( , )
Voici les arguments que cette fonction a besoin :
1 - Coordonnée en X de l'endroit où le tir sera créer
2 - Coordonnée en Y de l'endroit où le tir sera créer
3 - Vélocité du tir (vitesse du tir quoi, plus la vitesse tend vers 0 et plus il sera lent, plus il tend vers les extremum et plus il sera rapide ! Une vitesse négative est considéré comme une marche arrière)
4 - Angle de tir
5 - Type de tir
6 - Delay du tir, le retard avec lequel il sera tiré en gros

Maintenant on regarde les valeur mis a la place des arguments !

GetX et GetY sont deux fonctions interne de Danmakufu, permettant de récupérer les position en X et Y du boss ! Très utile lorsqu'on fait déplacer ce dernier de façon relativement aléatoire !

1, ce sera la vitesse de notre tir, un peut lent quand même ;)
90, ce sera l'angle de tir, voici un graphique tiré du site officiel de Danmakufu pour bien comprendre les angles ^^ (pour ceux qui connaissent la trigonométrie, faites attention, Danmakufu fonctionne dans le sens anti-trigo !)



BLUE01 sera le type de tir, donc voici le graphique (toujours tiré du site officiel)

Rajoutez devant chaque numéro une des couleurs suivantes : BLUE, RED, ORANGE, YELLOW, AQUA, GREEN, PURPLE, WHITE
01
02
03
04
05
11
12
21
22
23
31
32

et pour finir, le 6eme paramètre : 0, qui dit que le tir n'aura aucun retard et sera tiré immédiatement !

Pour conclure, CreateShot01(GetX , GetY , 1, 90, BLUE01, 0); créera un tir sur le boss, qui sera plutot lent, qui partira vers le bas de l'écran, qui ressemblera a une boule bleu, et sera tiré de suite.

Maintenant, je pense que vous aurez compris, mais le boss ne tirera jamais notre tir bleu... Pourquoi ? Car nous avons initialiser la variable count a -110, et pour faire feu, count doit être égal a 0 ! Comment faire ? Rien de plus simple ! Tout a la fin du bloc @MainLoop, vous allez rajouter une incrémentation de count !
Libre a vous de choisir l'incrémentation ^^
vous pouvez faire :

count=count+1; (on met dans count la valeur de count+1);
count+=1;
ou carrément count++;

les 3 expressions sont valable, libre a vous d'utiliser celle avec laquel vous vous sentez le plus a l'aise ;)

Maintenant, nous avons un second problème !
Avec l'incrémentation continue de count, il arrivera bien a 0, mais après, il continua d'augmenter et ne sera plus égal a 0 !
Bah y a pas plus con :) il suffit de créer une nouvelle condition pour remettre count a une valeur inférieur a 0 !

Code:

if(count==60)
{
            count=0;
}

Ou sinon, y avais plus simple depuis le début ! Utiliser le modulo ( % ) !
Non, pas pourcentage ^^ Mais modulo, c'est a dire qu'il va faire une division et s'assurer que votre valeur est bien un multiple !
donc il faudra changer votre condition, et mettre a la place de "count==0" un truc comme par exemple "count%30==0"
Pour faire plus clair, avec count%30==0, on s'assure que le tir partira a chaque fois que count sera un multiple de 30 ! (30, 60, 90, 120...)

Nouveau problème si on utilise le modulo (et bah, c'est bourré d'emmer** ce truc !) on se rend compte que même les valeur négative sont susceptible d'être des multiple de 30 ! Dans ce là, on rajoute dans notre condition un second traitement, dans lequel on ne prendra pas les valeur négative ! Pour ce faire, on rajoute entre 2 expression le signe && (qui veut dire ET) ou || (qui veut dire OU).
ps : n'oubliez surtout pas de toujours en mettre 2 !
ps2 : pour le signe OU, c'est Alt gr+8

au final, on se retrouve avec l'expression : if(count%30==0&&count>0)
pour traduire, ça donne : si ( count est multiple de 30 ET count est supérieur a 0 ) faire

C'est pas très net ? Vous inquiétez pas, avec la pratique ça viendra :)

Bon, si je me suis mal exprimé et que vous n'avez rien compris a comment écrire le fichier, voici en principe, ce que vous devriez avoir :

Code:


#TouhouDanmakufu
#Title[]
#Text[]
#Image[]
#Player[FREE]
#ScriptVersion[2]

script_enemy_main
{    
   let imgEnemy="script\ExRumia\img\ExRumia.png";
   let count=-110;
   @Initialize
   {
            LoadGraphic(imgEnemy);
            SetLife(1500);
            SetTimer(60);
            SetInvincibility(30);
            SetMovePosition02(GetCenterX, GetCenterY - 100, 120);      
   }
   
   @MainLoop
   {
      if(count%30==0&&count>0)
      {
                        CreateShot01(GetX , GetY , 1, 90, BLUE01, 0);
      }
      count++;
   }
   
   @Finalize
   {
      DeleteGraphic(imgEnemy);
   }
   
   @DrawLoop
   {
      SetColor(255,255,255);
            SetRenderState(ALPHA);
            SetTexture(imgEnemy);
            SetGraphicRect(64,1,127,64);
            DrawGraphic(GetX,GetY);
   }
}

CRÉATION DU PATTERN - DES EFFETS DE TIR !

On est bien d'accord, ce n'est pas avec un seul tir a la con qu'on va faire un pattern de folie !
Mais sachez que des fonctions de tir, y en a tout plein !
Bon, je ne les traiterais pas tous, mais sachez qu'il y a un tuto sur un wikipedia qui montre toutes les fonctions et les arguments qu'elles prennent : http://touhou.wikia.com/wiki/Touhou_Danmakufu

Je vais donc expliquer comment créer certains effet !

Par exemple, comment créer un cercle entier de tir ? On va quand même pas créer X tirs en changeant manuellement les valeurs, ça serais bien trop long, alors que le programmeur de base est un gros feignant :) Moins on en fait, mieux on se porte !

Voici donc ma fonction qui va créer pour moi, mon cercle de tir !

Code:

   task n_round(origine,velocity,acceleration,finalvelocity,bullet,n,sound)
   {
      PlaySE(GetCurrentScriptDirectory ~ sound);
      let angle=0;
      loop(n)
      {
         CreateShot02(GetX, GetY, velocity, angle+origine, acceleration, finalvelocity, bullet, 0);   
         angle+=360/n;
      }
   }

je vous explique tout ne vous inquiétez pas :)
placez ce bloc là où vous voulez, genre derrière @DrawLoop.
Pour l'appeler, rien de plus simple, a partir du @MainLoop, dans un bloc de condition, au lieu d'appeler la fonction CreateShot01 vus précédemment, vous appellerez a la place :

Code:

n_round(origine,velocity,acceleration,finalvelocity,bullet,n,sound)

Bien, donc, ma tâche possède 7 arguments, origine, velocity, acceleration, finalvelocity,bullet,n et sound.
origine, c'est la variable qui permettra de dire : a partir d'où mon cercle va viser ? A partir du joueur ? D'une variable aléatoire ? Ou simplement d'une valeur que j'ai mis en brut ?
velocity, c'est la vélocité, la vitesse de tir ^^
acceleration, c'est un des paramètre du CreateShot02 que j'appelle dans ma tâche, l'accélération permet d'accelerer le mouvement d'un tir jusqu'a une valeur défini par l'utilisateur (une valeur négative en accélération est considéré comme une décélération)
finalvelocity, si il y a acceleration, c'est ici qu'on définira la valeur final de la vitesse du tir
bullet, c'est le type du tir qu'on utilisera ^^ en gros : BLUE02, RED03, YELLOW23... Tout ce qui passera par la tête :)
n, c'est le nombre de tir qui composera notre cercle de tir, plus n est grand, plus l'écart entre les tirs sera petit, ce qui est logique ;)
et pour finir, sound, bah ce sera le sons qu'on lancera après avoir tiré ! Oui, parce que les effets sonores doivent être mis a la main :)

Bon, revenons sur ma fonction ! Je saute l'appel du PlaySE qui ne sert qu'a faire jouer le son, on tombe sur une définition de la variable angle, initialiser a 0, puis un bloc loop.
loop signifie boucle en english, donc en fait, le loop sera une commande qui va ré-itérer l'opération dans le bloc loop autant de fois qu'il le faudra, ici, n fois.

Maintenant, on se retrouve le CreateShot02(GetX, GetY, velocity, angle+origine, acceleration, finalvelocity, bullet, 0);
Dans l'ordre, GetX, GetY, velocity, on a déjà traité ça plus haut donc inutile de le reprendre ici :).
angle+origine maintenant, qu'es ce que c'est ? Normalement, c'est le champ dans lequel on saisie l'angle de tir, donc, notre angle sera a angle+origine !
acceleration, finalvelocity, bullet et le 0 de fin correspondent a ce qui a était dit plus haut.

Et pour finir, angle+=360/n;
Qu'es ce que ça veut bien dire ? Ça signifie que j'augmente la valeur de angle d'une somme égale a angle+360/n.
C'est une formule mathématique qui va me permettre d'augmenter la valeur d'angle de tir pour former un cercle "parfait" de tir.
Oui, y a beaucoup de math :) En même temps il faillais s'y attendre ;)

Je vais maintenant expliquer une autre fonction, particulièrement complexe a expliquer...

Comment faire rebondir un tir lorsqu'il touche un bord de l'écran ?

Code:

   task Bouncing_Bullet(x, y, v, angle, delay, bullet)
   {
            let obj=Obj_Create(OBJ_SHOT);

            Obj_SetPosition(obj, x, y);
            Obj_SetAngle(obj, angle);
            Obj_SetSpeed(obj, v);
            ObjShot_SetGraphic(obj, bullet);
            ObjShot_SetDelay  (obj, delay);
            ObjShot_SetBombResist (obj, true);
      let counter=0;

            while(Obj_BeDeleted(obj)==false)
      {
                    if(Obj_GetX(obj)<GetClipMinX&&counter==0)
         {
                          Obj_SetAngle(obj, 180 - Obj_GetAngle(obj) );
                          Obj_SetX(obj,  Obj_GetX(obj) + 0.1);
            counter++;
                    }

                    if(Obj_GetX(obj)>GetClipMaxX&&counter==0)
         {
                          Obj_SetAngle(obj, 180 - Obj_GetAngle(obj) );
                          Obj_SetX(obj,  Obj_GetX(obj) - 0.1);
            counter++;
                    }

         if(Obj_GetY(obj)>GetClipMaxY&&counter==0)
         {
                          Obj_SetAngle(obj, Obj_GetAngle(obj) -180 );
                          Obj_SetY(obj,  Obj_GetY(obj) - 0.1);
            counter++;
                    }

                    if(Obj_GetY(obj)<GetClipMinY&&counter==0)
         {
                          Obj_SetAngle(obj, Obj_GetAngle(obj) -180 );
                          Obj_SetY(obj,  Obj_GetY(obj) + 0.1);
            counter++;
                    }

         yield;
            }
   }

Pour Danmakufu, un tir, c'est un object, mais comme on créer des tirs avec des fonctions déjà toute faite, on ne s'en rend pas vraiment compte, cette fois, on est en plein dedans :)

La toute première ligne permet de créer notre objet : let obj=Obj_Create(OBJ_SHOT);
On défini notre objet comme étant un tir normal (OBJ_SHOT).
La variable déclaré ici (obj) permet d'avoir l'identifiant de notre tir, on va garder cet identifiant précieusement pour faire des test sur notre objet, jusqu'à sa destruction ;)
Les lignes qui suivent :

Code:

            Obj_SetPosition(obj, x, y);
            Obj_SetAngle(obj, angle);
            Obj_SetSpeed(obj, v);
            ObjShot_SetGraphic(obj, bullet);
            ObjShot_SetDelay  (obj, delay);

servent a décrire le tir (position en X / Y, angle, vitesse, graphique et delay), mais également rendre le tir indestructible ! => ObjShot_SetBombResist (obj, true);
Voilà pour ce qui est de la création de notre tir, maintenant, on va s'assurer qu'il rebondisse avant sa destruction !
Je déclare une variable counter, qui va permettre de compter le nombre de fois que le tir rebondira.

Et ensuite, on entre dans un bloc while. Le while serais traduit en français par "Tant que". Donc ici, on pourra traduire la ligne par : Tant que mon obj n'est pas détruit, faire...
L'écriture est barbare, mais a force de toucher les obj, on fini par s'y faire, donc ne vous inquiétez pas ;)
Il y a ensuite 4 traitements qui suivent, pourquoi 4 traitements ? Parce qu'il y a 4 bord :D
Et qu'es ce qu'on fait lorsqu'un tir touche un bord ? Et bah on change son angle de tir ;)

=> Obj_SetAngle(obj, 180 - Obj_GetAngle(obj) ); L'angle de tir est inversé par l'opération ( 180 - l'angle du tir )

Pour éviter l'abus sur le rebondi, on incrémente notre variable counter, pour que le tir ne rebondisse plus ;)

Voilà, on a créer un tir qui va rebondir une fois sur un bord de l'écran avant de disparaître !

Un petit truc sympathique maintenant, plus haut, il y a une tâche déjà créer, permettant de créer un cercle de tir ! On peut donc fusionner les deux tâches vus qu'elles ont étaient programmé de façon a fonctionner quelque soit les valeurs saisie !

en d'autre terme, on se retrouverais avec la tâche suivante :

Code:

   task Round_Bouncing_Bullet(x, y, v, angle, delay, bullet, n)
   {
      loop(n)
      {
         Bouncing_Bullet(x, y, v, angle, delay, bullet);   
         angle+=360/n;
      }
   }

Et lorsque vous lancez le test d'une SP en mettant cette fonction a répétition, savez vous ce qu'on obtiens ? Tout simplement la dernière SP de Flandre de EoSD !
Enfin, ou pas, car il fraudais demander au boss de se déplacer entre chaque tir, et augmenter régulièrement la vélocité des tirs, mais a coté de tout ce qui as était fait plus haut, ce n'est vraiment pas compliqué, au contraire ;)

Bien sûr, il y a de nombreuses autre façon de programmer tout ça, je n'ai fait que vous démontrer qu'une solution parmi tant d'autre !
De plus, ce ne sont que des exemples ici, il y a bien sûr de nombreux effet que l'on puisse créer ;) Les possibilités sont infinie !

CRÉATION DU PATTERN - FONCTION USUELLE

Cette fois, je me contenterais de parler des fonctions les plus utilisé dans Danmakufu, a savoir :

GetX() = Retourne les coordonnée en X du boss
GetY() = Retourne les coordonnée en Y du boss
GetPlayerX() = Retourne les coordonnée en X du joueur
GetPlayerY() = Retourne les coordonnée en Y du joueur
GetAngleToPlayer() = Retourne l'angle de tir qu'il y a du boss jusqu'au joueur (TRÈS utile)
Concentration01(frame) = L'élément indispensable lors du commencement d'une SP et lors des grosses attaques :)

rand(extremum_min,extremum_max) = Permet d'obtenir une valeur aléatoire compris entre 2 extremum. La valeur peut être n'importe quelle valeur, même les valeurs a virgule !
rand_int(extremum_min,extremum_max) = La même qu'au dessus, sauf que la valeur aléatoire retourné est obligatoirement entière.

SetMovePosition02(X,Y,frame) = Permet de déplacer le boss aux coordonnée indiquée en un certain nombre de frame (plus frame est élevé, plus le déplacement sera long, et inversement)
SetMovePositionRandom01(Deplacement_en_X, Deplacement_en_Y, Velocity, limite_gauche, limite_haut, limite_droite, limite_bas) = Permet de déplacer le boss de façon totalement aléatoire (en spécifiant certaines limite)

CreateShot02(X, Y, Velocity, angle, acceleration, Final_Velocity, Bullet_type, Delay) = Permet de créer un tir, bien plus intéressant que CreateShot01 car il gère l'accélération et la décélération du tir ;)

CreateLaserA(id,x,y,longueur,largeur,type_de_tir,delay_avant_activation) = créer un objet de type laser
SetLaserDataA(id, delay_modifcation, angle, vitesse_de_rotation, acceleration, velocity_max, type_de_tir) = modifie les valeurs du laser
SetShotKillTime(id, frame) = donne une durée de vie pour le tir id
FireShot(id) = permet de faire feu avec le tir id
/*Ses 4 fonctions fonctionnent ensemble, le laser ne peut pas faire feux s'il n'y a pas le CreateLaserA, SetLaserDataA et le FireShot(id) !

PlaySE(GetCurrentScriptDirectory ~ "SFX\power0.wav") = Permet de jouer un sons (pour éviter d'avoir un jeu sans le moindre son ;))

J'en oublis sans doute, y a tellement de chose a dire là dessus... J'espère avoir était clair, au pire des cas, n'hésitez pas a poster un message pour demander une explication sur certains points :p

(je me permet de réserver cette emplacement au cas où j'aurais encore un truc a dire ^^)
(ps : Désolé du quadruple post, mais on est apparemment limité en caractères ^^')

Bravo pour ce tuto !
Je vais pouvoir essayer Danmakufu maintenant ^^

Merci Sety...mais c'est foutu pour moi TAT je peux pas lancer Applocale TAT

Euh c'est pas moi qui ait écrit ><

Moi, j'arrive pas à le DL >_>

Un lien? pliz TT_TT

Merci Dynast ! Grâce à toi, j'ai réussi à faire marcher Danmakufu ! \O/

Oh Dynamite, you're my hero =3

content a écrit:Moi, j'arrive pas à le DL >_>

Un lien? pliz TT_TT

Qu'es ce que tu n'arrive pas a DL ? Danmakufu ou Applocal ? Si c'est Applocal, j'ai également eu des problème avant d'en trouver un qui marche, suffisamment de problème pour tenter d'héberger celui que j'utilise sur internet s'il le faut ^^

Ouais, héberge, ça sera plus facile.

Voilà, j'ai éditer mon premier post, tu trouvera un lien vers le AppLocal que j'utilise dans la partie Téléchargement ;)

Arf. J'ai des bugs de téléchargement. Tu peux pas en faire une archive sous winrar et la mettre avec MégaUpload? Désolé, mais c'est mon PC pourrit qui veut pas >_>

Pour le moment je n'ai pas le temps de tester ça mais je le ferais demain !

Merci beaucoup pour avoir pris la peine de poster un tutoriel !

Ps : You are my hero :)

merci pour le tutoriel ^^

Bien voici quelques précisions et quelques questions :

- L'applocal est necessaire aussi sous vista

- L'applocal à un problème d'installation sous vista. J'ai trouvé un truc à cette adresse que je vais tester : http://www.mydigitallife.info/2007/05/26/workaround-to-install-microsoft-applocale-utility-in-windows-vista/

Edit : L'installation marche, mais je n'ai pas réussis encore à lancer le jeu sans que ça plante. Il faut le lancer à partir de Applocal ? Si oui je fais comment moi ( j'avoue que j'ai jamais trop compris le truc là )


Ensuite la question :

- Pour les patterns, tu parle de coordonnées X et Y vers où les bullets sont envoyées si je me trompe pas. Un écran de touhou a combien de longueur X et combien de largeur Y ?

OH MY GAAWD~ !
Sa a l'air facile et dur en même temps T-T
Merci pour le tuto Dynast maintenant je crois que je réussirais a faire quelque chose (j'espère...) ^^"

.

Oui mais je trouve pas applocale ^^'

.

Non je parle bien sur mon ordinateur. Je suis sur que la réponse est vraiment bête, mais quand j'ai installé l'applocal il ne m'a pas demandé de chemin de destination. Du coup je sais pas où il l'a mis. Je vais voir pour ton applocal !

hiiiiiiiiiii hiiiiiiiiiiiiiiiiii je vais commencer tout de suite....euh non plutot samedi car demaine suis bloquer a cause d'un truc toute la journée -_-"


merci d'avoir poste ce Topic Dynast ^^

Houla c'est du lourd ce tuto ... Mais tu as beaucoup de courage pour écrire tout ça, Dynast !!!
Merci ^.^

Génial ce tuto, grâce à toi j'ai pu faire mon premier boss sur Danmakufu. Merci.

Hop vidéo !


Il possède 4 spellcards, je donne le lien si ça interesse qqun un travail de gros débutant: ICI
(Il faut juste mettre le dossier Troll dans le dossier Script de Danmakufu.)

Krag a écrit:Génial ce tuto, grâce à toi j'ai pu faire mon premier boss sur Danmakufu. Merci.

Bah écoute, de rien ^^

J'avais peur au début que ce soit trop flou ou que j'ai sauté des points important =)

EDIT : Sympa quand même comme SC =)