Stéganographie et Level Editor (niveau débutant).

Salut!

Auteur du tuto. >> Spring Up, la seule personne à avoir reçu le titre de TGF Master, par une grande communauté RPG Maker.

Le cours est valable pour un jeu basique, genre casse briques, sokoban, atomix, rpg old school.

Prototype Labytude compatible CTF 2.5 free. >> 11 niveaux cryptés (niveau avancé).

Derrière ce cours, il y a un travail acharné, des tests, des mises en pratiques.

Le mapping avec un klik soft, revient à résoudre un casse tête chinois, quand il s'agit de réaliser tuile par tuile, à la souris, un monde rpg (des centaines de maps).

Dans le but de gagner du temps, il existe des stratégies d'ensemble, des stratégies mapping, le cours propose une méthode, parmi d'autres, simple à mettre en œuvre pour un "petit" jeu.

Une stratégie mapping répond à un cahier des charges, le cahier des charges définit les objectifs à atteindre, pose de façon limpide les problématiques à résoudre.

Celle proposée sort de l'ordinaire, il s'agit de crypter, décrypter un layer afin d'afficher des niveaux.

1) Notion de programmation >> Level Editor >> Layer Editor.

N'étant pas un programmeur professionnel, pour ma part un "Level Editor", ressemble fort pour un monde "rpg", à un éditeur de map, un éditeur d'objets interactifs.

Généralement un programmeur, passe par un tableau pour afficher un level "rpg", en loua (entièrement gratuit et libre), il y a des lignes, des colonnes, et une tuile (sol, obstacle, monstre, fraise) à afficher via un numéro, du genre.

0 = Le sol.
1 = Un mur.

Pour un donjon voilà en gros le principe.

000000000
011110000
010010000
010010000
000000000
000000000

Par dessus un autre tableau avec un monstre, une fraise.

2 = Un monstre.
3 = Une fraise.

000000000
000000000
000300000
000000000
002200000
000000000

Inutile de s'attarder sur la numérotation de chaque ligne, de chaque colonne du tableau, bref en langage code = Quelle galère!

Avec CTF, un pseudo langage de programmation, le klik and play code, permet une mise en pratique beaucoup plus rapide, essayer de faire une translation "Level Editor" mot à mot, du langage code loua est une perte de temps, autant devenir un programmeur professionnel.

Ce qui doit être adapter >> le principe, pas le folklore.

L'objectif principal à atteindre:

Afficher un Level "rpg" / Afficher un Level "rpg" / Afficher un Level "rpg".

En gros, pour appréhender le travail à fournir.
https://opengameart.org/content/tiny-16-basic



2) Stéganographie >> Cryptage et décryptage.

Avant propos concernant la méthodologie >> Stratégie mapping:

La méthode s'applique à un niveau (rpg) non aléatoire, du fait à la "main" tile par tile.

Un traducteur de map réduite, du Bump, de la stéganographie pure et dure, des tonnes de tableaux, des boucles rapides, du gloubi-boulga, etc, ne changera rien au fait que le niveau doit être "mapper" de façon fastidieuse, lorsque le projet le nécessite.

Mapping >> Réalisation de carte avec des tuiles "rpg".

Le map and coding, réclame beaucoup d'expérience, afin de gérer les déplacements, les collisions, les plans, la sauvegarde, etc.

Il y a des trucs difficiles à capter, alors voici l'essentiel, pour des niveaux réalisés tile par tile (stratégie de la fourmi), le plus simple est un jeu de tampons.

Suite au tamponnage, une capture d'écran, cette capture d'écran, ressemble fort à un layer.

Donc le jeu de tampons est un "Layer Editor" (stratégie de la cigale).

Au lieu d'avoir le tableau numéro 1, le tableau numéro 2, etc, il reste un layer.

Le petit souci avec la stratégie de la cigale, est l'utilisation de plusieurs couches ou layers, un peu lourd à gérer dans certains cas (map isométrique).

Suivant le projet, il est possible d'insérer du code dans le layer, donc de crypter et décrypter afin de finaliser un seul layer.

Dans le domaine de la stéganographie, imaginer des systèmes (cryptage, décryptage), est amusant tant que le support reste lisible.

Voici en image, un code simple pour un layer.



La tuile de base sert de support au code, en fait il s'agit d'un layer décomposé, une tuile de base découpée en quatre, avec des couleurs, afin de mieux se repérer.

Un curseur entre en collision avec le layer mis au point, décryptage, affichage des ressources graphiques.

Pour se faire, les tableaux (vus précédemment) ne représentent qu'une seule et même grille, cette grille est composée de cases, chaque case doit avoir au moins un numéro.

0 = Le sol. >> inutile avec CTF (décor rapide).
1 = Un mur.
2 = Un monstre.
3 = Une fraise.

Le nouvel objectif à atteindre étant, zéro tableau, un seul layer, pour afficher un "Level rpg", CTF doit être capable de décrypter environ une centaine de numéros (pour un tileset), à l'aide d'une collision.

128 tuiles avec un numéro, décrypté à l'aide d'un curseur (déplacement d'un actif, vert sur le layer).



En langage "préphrasé", au lieu d'avoir un paquet de numéros à insérer dans un tableau, on a un layer qui délivre un numéro, suite à un coup de tampon.

8)

Piano, molo, une petite mise en pratique niveau débutant, à améliorer forcément, la mise en pratique étant une initiation à la stéganographie (cryptage, décryptage d'un layer), l'objectif n'étant pas de rebuter.

Un curseur entre en collision avec le layer, "créer un objet", un compteur affiche une valeur (numéro).

Le numéro permet de déterminer le numéro de l'image de l'objet actif.

Pour ce tour de force, dans l'exemple proposé "lourding" pour être compris, il est nul besoin d'une extension, d'une boucle rapide.

L'affichage du niveau se fait à l'aide d'une condition.

Bien sûr, il est possible de combiner plusieurs, curseurs, couleurs, compteurs, d'utiliser en prime une ou des boucles rapides, tout dépend du projet.

Évidemment, l'objet actif "Level rpg", peut contenir des centaines de layers (niveaux).

Layer crypté.



Level "rpg" décrypté à l'aide d'un curseur.



L'inconvénient de la méthode, est sa mise en route, car une tuile codée = une tuile pour 1 numéro.

Une image possède un code "naturel", donc indispensable, le code couleurs RGB.

Une couleur = un code RGB, un code RGB ne peut pas afficher trois couleurs, en gros les trois couleurs sont mélangées dans un pot de peinture, il ne peut en sortir qu'une seule couleur.

Un pixel = un code RGB = une couleur.
__________________________________

L'extension, "Pixel Object" permet de lire le code couleurs RGB, elle est simple à utiliser.

Décryptage d'un layer (128 couleurs), avec "Pixel Object".

https://mega.nz/#!DEIglLqC!MHaR7n2JJyjGdmtgOlVTLUOFzfTlm_w5Kf3pSKPAfv4
__________________________________

Un débutant peut utiliser 31 tuiles sans problème, grâce à une palette RGB, généreusement offerte.

https://mega.nz/#!OAhT3Y7a!3TiWtfyFMfLbP4FMqCOC07WUPnhSBpyIWrTJt-Ey1kE
__________________________________

Le clikeur plus expérimenté, se doit de mettre en place, un système code et palettes RGB, afin de bénéficier de plus de tuiles.

La méthodologie est faite pour des niveaux à réaliser tuile par tuile, stratégie de la fourmi, il y a des projets où le mapping est indispensable.

Dans ce cas puisque réaliser un niveau, une map à la souris est obligatoire, autant en profiter pour glisser des numéros via le code couleurs RGB, au lieu d'utiliser un paquet de tableaux pour afficher les niveaux.

De surcroît, il est plus facile de modifier des layers, qu'un paquet de tableaux.

La méthodologie pragmatique, révolutionnaire comme le fil à couper le beurre, présente pas mal d'avantages, que vous découvrirez seulement en mettant en pratique.

Décryptage d'un layer, réalisé tuile par tuile à la souris, pour une capture d'écran (stratégie mapping de la fourmi et de la cigale).



Bien sûr il est possible de placer, lors de la conception du layer tuile par tuile, des layers décomposés afin de gagner du temps.

Un layer décomposé peut ressembler à la partie d'un donjon, déjà cryptée.

Les astuces étant nombreuses...

© Stéganographie n'est pas philosophie © >> Humour!

Mise en pratique (initiation stéganographie) en pièce jointe.

Cordialement.

A+++

Comment tu enregistres tes niveaux/map  de l'éditeur pour qu'ils puisses être chargé en "jeu" plus tard ?

Edit :
J'avais pas vu que c'était une image le "niveaux"

Merci de ton retour Monos, j'ai oublié de donner le nom au layer "Level rpg".

Touche [2] Num >> Level rpg 2.

Touche [3] Num >> Level rpg 3.

Test2 en pièce jointe.

 

Pas mal !
Je me suis permis d'adapter ton tutoriel sur la stéganographie. Ma méthode diffère de la tienne, dans le sens où je vais lire la couleur de chaque pixel d'une image de 32x32. Chaque couleur correspond à un objet bien déterminé.

Merci infiniment pour ton exemple Cyberclic, tu peux tout te permettre.

Pour le lecteur de passage, je précise que tu es parti d'un template (modèle), afin d'afficher instantanément le "niveau rpg", à l'aide de boucles rapides, et surtout le fameux "RGB Color Code".

Le code couleurs indispensable, en stéganographie.

Édit:
Le projet "Baballe" utilise aussi le code RGB, via une condition.

J’avais pensé que tu utilisait les couleurs, comme dans la méthode dont parle Cyberclic.
Ta méthode est intéressante. En l’état, ça fait que chaque tuiles peuvent être codées sur 4 pixels, ce qui fait au total 16 tuiles. Ce qui me parait embêtant c’est que si on veut plus de tuiles possible il faut plus de curseurs.

(edit) Tu as vu mon exemple pour peindre un décore ? J’utilise un fichier texte mais le principe est le même que ce qu’a fait Cyberclic.

Merci de ton retour Seyjin.

J'ai pris le temps de regarder ton exemple pour peindre un décor.

Ma mise en pratique est limitée à moins de l'améliorer, je n'en disconviens pas.

Hello!

Des explications supplémentaires?

Sans utiliser de logiciels externes à CTF, autrement on se retrouve sur "Enterprise".

En théorie le nombre de codes à quatre chiffres qu'une carte bancaire peut avoir est, tin, tin ,tin...

10 000 codes sur un clavier soit 10*10*10*10, entre parenthèses les banques feraient bien de m'embaucher, la stéganographie n'est visiblement pas leur domaine.

Attention humour, même pour 500 000 euros à la seconde, je n'encouragerai jamais le système bancaire actuel.

Comme dit précédemment, le code couleurs, en stéganographie informatique, est indispensable.

En théorie quel est le nombre de numéros possibles, suite à un cryptage avec CTF?

Voilà l'énigme à résoudre sachant que n=R*G*B.

A+++

Edit:
Un indice, tester le code RGB possible avec l'éditeur d'image.

Pour la version amélioré que j’utilise dans Slimetales, j’utilise un tableau pour lister les tuiles au lieux de faire une ligne à chaque fois.

De mon point de vue, la méthode que l’on utilise doit répondre à une question : « Qu’est ce que je veux faire avec ? ». Utiliser une méthode plutôt qu’une autre doit servir un objectif. Par exemple pour les cartes de jeux  Pico 8, ça simplifie énormément le partage tout en utilisant peu de mémoire.
Avec ma méthode, je voulais un niveau facile à éditer qui puisse avoir une longueur variable et une hauteur d’un écran. En plus, la suite du texte peut servir de fichier ini pour stocker le nom du niveau, celui tileset, ou bieu d’autre choses.

[quote]Voilà l'énigme à résoudre sachant que n=R*G*B.[/quote]
256*256*256  si c'est codé sur 1 octets par composant soit des graphismes 24 bitounets !

[…] 24 bitounets !

C’est pas un nombre ça. Faut dire 2²⁴  8)

Bravo pour le calcul savant et combiné Monos.  :bravos

256*256*256 = Bienvenue sur "Enterprise".

:D

La solution de l’énigme en image.



En l'état, il me semble que cela ressemble à 32 numéros.

En théorie n=32*32*32=32768.

32768>16.

Edit: Vous devriez prendre le temps de me relire pour saisir quelques subtilités.

Par ailleurs, la solution de l’énigme, se trouvait dans "Sreenshots".

"En théorie 32x32=1024, nombre de numéros possibles pour chaque case (tile),
largement suffisant. "

Donc avec deux palettes R et B, 2 compteurs et 2 curseurs, cela devrait suffire.

Attention la palette R/G/B doit commencer à R/G/B=8 jusqu'à 248, un actif ne supporte pas 256 seulement le 255 (lol).

Dans la pratique, sans forcer, avec une palette "codée" avec CTF, on peut afficher 31 briques différentes dans un arkanoïd like, via une condition qui régurgite un numéro mis dans un layer, à coups de tampons.

En forçant un peu, sans se tordre un ongle, 256/2, soit 128 briques différentes possibles, une palette RGB, 1 compteur et 1 curseur.

Pour plus de briques, donc de tuiles différentes, il est besoin d'une formule, de réaliser autant de palettes que nécessaire, plusieurs compteurs, plusieurs curseurs .

Merci de votre attention, il y a des codeurs qui se casseraient une jambe, pour avoir l'immense privilège de lire mes explications gratuites, je vous laisse "deviner" pourquoi.

Je crois que j'ai capté ce principe en jouant à Defender en 1984. C'était la minimap qui appelait les sprites du level a mesure que le scrolling avançait.

Je crois que j'ai capté ce principe en jouant à Defender en 1984.

Tu veux dire que Kloug n’as pas révolutionné la manière de penser les jeux vidéo ?  :o

J'ajoute que c'est très pratique pour faire des terrains en 3d issus de pixels en niveaux de gris. Bump mapping. Je fais un tuto dès que j'ai 5 minutes... Avec les filles sur les bras en ce moment je ne fais... Rien...

Voilà, j'ai volontairement fait une seule boucle en X (pas de double boucle) pour que vous que les novices comprennent plus facilement le principe.
Désolé pour le manque de peaufinage, je fais au mieux...

Oh c'est génial! je savais pas qu'on pouvait lire une valeur rvb aussi facilement!
Des niveaux d'une rapidité incroyable!

merci merci!

Excellent Pat  :bravos

Je crois que j'ai capté ce principe en jouant à Defender en 1984. C'était la minimap qui appelait les sprites du level a mesure que le scrolling avançait.

C'était vachement bien defender !!! les petits gugus à sauver, le vaisseau qui chaéngeait de direction (enfin si je me rappelle bien !). Un bon shoot.
Maintenant les shoots c'est 3 milliards de tirs...