Convertir une image pour Warioware diy
Tous d'abord , bonjour à tous .
Je suis néophyte en programmation java et sur le forum et j’espère ne pas tomber hors sujet en vous demandant quelques conseils .
Je suis motivé pour apprendre donc juste une petite remarque serai très sympathique .
Je vais essayer d'être claire et précis malgré mes faibles connaissance , quitte à me répéter , pour être bien compris .
Je voudrais trouver un moyen de copier rapidement une image sur mon ordinateur dans le jeux vidéo nintendo ds Warioware diy .
Pour ceux qui ne connaisse pas , Warioware diy est un jeux composé de micro jeux de quelques secondes et qui offre la possibilité d'en créer soit même avec un éditer de background/sprite ( comme celui de mario paint sur snes ) et un langage très simple de programmation ( ce jeux à pour vocation d'enseigner des bases de programmation aux jeunes et débutants )
Le jeux se joue au stylet sur un écran tactile comme une souris .
La palette de couleurs pour la création d'éléments est limitée à 14 couleurs prédéfinies .
La démarche , qui me semble la plus approprié , pour éviter d'avoir à créer pixel par pixel un dessin dans le jeux serais de faire un programme en java qui analyse une image pré-configurée ( taille et couleurs ) et la retranscrit en un fichier lisible par un émulateur nds composé d'input .
Je m'explique :
Premièrement , pour un background , la taille proposée est de 192 x 128 pixel .
J'ai une image qui m'intéresse :
http://img15.hostingpics.net/pics/91...shotbefore.gif
Je la modifie sur gimp pour quelle ai la bonne taille et les bonnes couleurs :
http://img15.hostingpics.net/pics/72...wariowares.gif
J'ai utilisé la palette de warioware suivante :
http://img15.hostingpics.net/pics/25...yemoluvjd2.gif
Je pourrai recopier chaque pixel dans le jeux sur émulateur ou console mais ce serait très long .
Donc deuxièmement , comment l'émulateur se comporte et quel langage interprète t'il .
J'utilise DeSmuME 0.9.10 x64 .
Cet émulateur permet d'enregistrer les pressions de boutons et de stylet image par image ( a raison de 30 par secondes ) a partir du lancement du jeux et de les relire automatiquement toujours a partir de la première image ( frame ) .
Il crée un fichier .dsm qui , une fois l’extension modifié en .txt , est modifiable et lisible sur windows . J'ai commencé par enregistré des inputs manuellement ( en temps réel ) et regardé comment il les écrit . Il commence par des informations sur la rom et ensuite chaque input même si rien n'est pressé . Une image/frame est écrite de cette manière :
Citation:
|0|.............132 080 1|
132 correspond à l'axe x de l'écran tactile
080 correspond à l'axe y de l'écran tactile
1 au fait qu'il y est une pression
Par exemple qu'il y ai une pression de deux frames au stylet à la pixel 132,80 et ensuite un relâchement ( aucune pression ) pendant 4 frames s'enregistrera ainsi :
Citation:
|0|.............132 080 1||0|.............132 080 1||0|.............000 000 0|
|0|.............000 000 0||0|.............000 000 0||0|.............000 000 0|
(ps:j'ai mis à la ligne pour plus de lisibilité)
Voyons voir maintenant quelles infos sont nécessaire pour qu'il dessine tous seul une image , dans le cas présent un background de 192x128 .
D'abord les input que j'enregistre manuellement pour qu'il navigue dans les menus jusqu’à un background vierge , avec l'outil crayon réglé sur un trait d'une pixel .
Voici des screenshot du programme configuré pour qu'il m'indique visuellement quelle pixel est pressée ( une ou un pixel ? je sais jamais . On va dire féminin , c'est plus sexy )
http://img15.hostingpics.net/pics/586496Capture3131.jpghttp://img15.hostingpics.net/pics/20...ture222158.jpg
L'axe 31,31 de l'écran tactile correspond à la première pixel en haut à gauche de mon background ( pixel 0,0 ou 1,1 )
L'axe 222,158 de l'écran tactile correspond à la dernière pixel en bas à droite de mon background ( pixel 191,127 ou 192,128 )
Le calcul est simple . Si je compte la première pixel de mon image à l'axe 0,0 : j'additionne 31 , et à 1,1 : 30
Les inputs pour qu'il dessine un point en haut à gauche et un point en bas à droite a partir de ce moment ( menu ) seront les suivant :
Citation:
|0|.............031 031 1||0|.............000 000 0||0|.............000 000 0|
|0|.............222 158 1||0|.............000 000 0||0|.............000 000 0|
J'ai fais un test pour voir quel rythme il peut soutenir . Il a besoin d'une frame de pression et deux de relâchement entre chaque pression .
Par exemple je veut trois trois damier de deux pixel de gauche à droite reparti sur la hauteur , un changement de couleur et enfin un damier violet en haut à gauche :
Citation:
|0|.............031 031 1||0|.............000 000 0||0|.............000 000 0|
|0|.............032 032 1||0|.............000 000 0||0|.............000 000 0|
|0|.............033 031 1||0|.............000 000 0||0|.............000 000 0|
|0|.............034 032 1||0|.............000 000 0||0|.............000 000 0|
etc ...
|0|.............031 065 1||0|.............000 000 0||0|.............000 000 0|
|0|.............032 066 1||0|.............000 000 0||0|.............000 000 0|
etc ...
|0|.............044 126 1||0|.............000 000 0||0|.............000 000 0|
|0|.............045 125 1||0|.............000 000 0||0|.............000 000 0|
etc ...
|0|.............099 009 1||0|.............099 009 1||0|.............099 009 1|
|0|.............000 000 0||0|.............000 000 0||0|.............000 000 0|
( clic sur le violet avec temps nécessaire )
|0|.............031 032 1||0|.............000 000 0||0|.............000 000 0|
|0|.............032 031 1||0|.............000 000 0||0|.............000 000 0|
etc ...
Résultat dans l'émulateur :
http://img15.hostingpics.net/pics/99...oWaretest2.png
Troisièmement : les taches que le programme devrait exécuter .
Il faudrait que le programme puisse importer une image ( je ne sais pas quel format serait le plus approprié )
et qu'il détermine quelles sont les axes x,y de chaque couleurs ( en donnés rvb/rgb ou index de palette )
Qu'il les convertisse à l'axe désiré dans le jeux en y additionnant soit 30 ou 31 ( dépendant de ça façon de compter )
Qu'il les convertisse ensuite en donnés lisible par l'émulateur ( |0|.............000 000 0|) avec pour règle de rajouter deux frames entre chaque point ( il faut aussi que ca soit ecrit en trois chiffre avec 1 = 001 , 22 = 022 , 122 = 122 )
Qu'il puisse créer un fichier .txt
Qu'il y insère au début les inputs prédéfinis ( enregistrés manuellement ) à la navigation dans les menus jusqu'à l'éditeur de background vierge avec un trait de 1 pixel et le noir sélectionné .
Qu'il y insère les axes convertis de toute les pixels de la même couleur ( noir en premier )
Et qu'il y insère entre les valeurs des axes des pixels les inputs prédéfinis pour un changement de couleur .
Je voudrait savoir :
Si d'après vous Java est approprié pour effectuer ce genre de taches et quelles style de librairie utiliser ?
Si la méthode que j'envisage vous semble correcte ?
Si ce que je voudrait faire est irréalisable ou plus complexe qu'il ne m'y parai ?
Si je ne suis pas trop hors sujet ( but puéril ) et si je ne dénature pas trop votre forum ? ( si oui , vers quelle forum/site me conseillerai vous de me tourner pour expliquer mon problème )
Merci pour toutes réponses , conseils , indices , liens vers tutos et critiques .
