0) Pré-requis

• Une PS4 en 4.05 ;
• Un PC (nous utiliserons Windows dans ce tuto. Vous pourrez aussi réaliser ce tuto sur Linux ou Mac, avec Wine pour installer les fichiers du SDK. Les commandes tapées dans le CMD seront identiques à celles que vous pourrez taper dans votre Terminal) ;
• Une gestionnaire d’archives (comme 7zip) ;
• Python 2.7.14 ;
• Visual Studio 2013 (2015 marche sans doute, mais nous ne l'avons pas testé) ;
• Le PS4 SDK 4.50 patché avec les fichiers du PS4 SDK 3.50 ;
• Des compétences de base en informatique, ça va de soit.

Les fichiers du SDK PS4 ne seront pas partagés dans cet article pour des raisons de légalité. Vous pouvez les trouver en demandant aux bonnes personnes ! Vous trouverez plus d'informations en bas de cette page.

1) Installation des fichiers nécessaires

Une fois les fichiers (trouvés par vos soins) téléchargés, vous pouvez extraire les fichiers du SDK. Exécutez SDK_Manager.exe en tant qu'administrateur.

Vous pouvez installer le tout si vous le souhaitez (y compris les samples). Vous pouvez aussi vous contenter du SDK, mais nous nous servirons de certains samples dans ce tutoriel. Par contre, ce qui est vraiment important, c'est de désactiver toutes les mises à jour et d'activer seulement le SDK Patch - 4.508.101 (contenu dans le dossier Update (2017-05-31)). Cette mise à jour truquée contient en fait les fichiers du SDK 3.50.

2) Utilisation du PS4 SDK

Une fois installé, vous pouvez lancer Visual Studio 2013 (en tant qu'administrateur, c'est important). Créez un nouveau projet pour PS4.

Vous pouvez également utiliser les samples déjà pré-installés si vous les aviez sélectionnés pendant l'installation. Rendez-vous dans C:\Program Files (x86)\SCE\ORBIS SDKs\4.500\target\samples\sample_code pour trouver ces samples. Quelques uns ne sont pas compatibles pour diverses raisons (certains nécessitent une PS4 devkit par exemple).

Pour ce tutoriel, nous allons prendre le projet situé dans "sample_code\graphics\api_font".

Cliquez sur Fichier > Ouvrir > Projet / Solution et sélectionnez votre sample (ici, donc, api_font.sln). Une fois lancé, vous verrez le code du projet. Je ne vais pas vous expliquer le fonctionnement du code de api_font car il est un peu complexe, mais si vous voulez vous amuser, vous pouvez modifier le texte contenu dans cette variable à la ligne 620.

Une fois votre code prêt, cliquez sur Build > Build Solution :

Une fois la construction terminée, rendez-vous dans le dossier \api_font\ORBIS_Debug\. Vous y trouverez le fichier simple_step.elf. Renommez-le en eboot.bin.

3) Signer les fichiers

Créez un dossier, où vous le souhaitez, qui va contenir votre homebrew. Placez-y le fichier eboot.bin, ainsi que le dossier sce_sys contenu dans cette archive. Si vous le souhaitez, vous pouvez changer l'icône.
Créez ensuite le dossier sce_module.

Dans le dossier \api_font\simple_step\sce_module\ ont été générés deux fichiers : libc.prx et libSceFios2.prx. Copiez ces fichiers dans sce_module. Votre dossier devrait ressembler à ça :

Maintenant, nous allons devoir signer l'eboot et les modules. Téléchargez le fichier make_fself.py à cette adresse, et glissez-le dans le dossier de votre homebrew, ainsi que dans le dossier sce_modules. Lancez ensuite l'Invité de commande et rentrez les commandes suivantes :

cd "chemin-vers-le-dossier-de-l'homebrew"
make_fself.py eboot.bin eboot.bin
cd sce_module
make_fself.py libc.prx libc.prx
make_fself.py libSceFios2.prx libSceFios2.prx

Une fois les fichiers signés, retirez make_fself.py du dossier. Nous allons maintenant construire le fichier .PKG installable sur votre PS4.

4) Construction du package

Commencez par télécharger cette archive, qui contient les outils nécessaires à la création de .PKG. Exécutez orbis-pub-sfo.exe, cliquez sur File > Open et sélectionnez le fichier param.sfo (présent dans le dossier sce_sys)

Éditons le param.sfo !

Ici, vous pourrez changer l'ID de votre application ainsi que son nom (Title Text). Sélectionnez le contenu de la case Content ID et copiez-le quelque part où vous pourrez le retrouver facilement plus tard (ici UP9000-NPXX12346_00-TESTAPP200000000).

Une fois vos modifications effectuées, sauvegardez en cliquant sur File > Save.

Fermez cette fenêtre, et exécutez le fichier orbis-pub-gen.exe. Vous allez vous retrouver face à cette fenêtre :

Double cliquez sur Image0. Une nouvelle fenêtre va s'ouvrir. Glissez-déposez-y (ça m'a fait aussi mal de l'écrire que vous de le lire) le contenu entier du dossier de votre homebrew. Votre fenêtre devrait alors ressembler à ça :

Rendez vous dans l'onglet Chunk, faites un clic droit sur Image0 Root, glissez votre souris sur Switch Chunk Assignment of the File(s) et sélectionnez #0 : Chunk #0.

Vous pouvez maintenant fermer cette fenêtre. De retour sur la fenêtre précédente, cliquez sur Command > Project Settings. Allez maintenant dans l'onglet Package et collez le Content ID que vous avez récupéré plus tôt et sélectionnez "Freemium App".

Dans la case Passcode, mettez uniquement des "0". Ainsi, ils pourront être décryptés et modifiés par d'autres utilisateurs ;)
Toutefois, si vous êtes un égoïste, vous pouvez mettre autre chose (mais sachez que l'Univers ne vous apprécie pas beaucoup).

Une fois tout ceci configuré, cliquez sur "OK", puis sur "Build" lorsque vous en aurez l'occasion. Une autre fenêtre va alors s'ouvrir : sélectionnez l'endroit où votre fichier .PKG sera enregistré dans Output Path. Cliquez sur "Build".

La création du package va commencer ! Une fois terminée, vous aurez ce message:

Si tout s'est bien passé, vous devez trouver votre fichier .PKG à l'adresse de destination entrée précédemment.

5) Installation du package sur la PS4

Pour installer l'homebrew sur votre PS4, mettez votre fichier .PKG fraîchement généré sur une clé USB ou un disque dur formaté en FAT32 ou ExFAT (la console ne le reconnaîtra pas sinon). Lancez le hack (retrouvez notre tuto à cette adresse, si vous ne savez pas faire). Une fois terminé, transférez le payload PS4HEN sur votre console.

Si tout s'est bien déroulé, vous voir une option supplémentaire à la fin de vos paramètres : Debug Settings (avec la petite étoile devant).

Branchez votre clé USB à votre console et naviguez dans Game > Package Installer : vous verrez votre fichier .PKG ! Sélectionnez-le et installez-le. Allez ensuite dans le menu de votre PS4 

Vous pouvez évidemment lancer votre bel homebrew (sinon, quel est l'intérêt ?) :

Voilà voilà, vous savez maintenant comment construire des homebrews pour PS4 ! Plus d'excuses, développeurs et apprentis développeurs, développez vos meilleurs homebrews et jeux ! 

5) Post Scriptum

Nous allons ici revenir sur quelques points sur lesquels nous sommes passés trop rapidement dans ce tutoriel. 

Tout d'abord, nous ne partagerons pas dans cet article les fichiers du SDK PS4 officiel. Il s'agit en effet d'une suite de logiciels sous licence, et nous ne tenons pas à avoir de problèmes avec Sony (et accessoirement, la justice). On ne vous remet pas le petit panneau, mais on vous rappelle juste que la peine endurée peut s'élever jusqu'à 300 000€ et 3 ans d'emprisonnement. Sachez aussi que tout lien vers le SDK dans les commentaires de cet article (et n'importe où sur ce site/forum) sera systématiquement supprimé et le posteur pourra être banni.

Pour la petite histoire, il y eu d'abord un leak du SDK PS4 4.50, mais malheureusement il ne fonctionnait que pour les PS4 en firmware 4.70 minimum (étrange, n'est-ce pas ?). Donc, j'étais un peu bloqué quand un ami (Darbness, merci à lui) m'a contacté et donné les fichiers du SDK 3.50, qui lui est compatible avec le firmware 4.05. Nous avons donc fusionné les fichiers du 3.50 avec ceux du 4.50 pour obtenir un SDK fonctionnel.

Concernant le code du sample utilisé dans ce tutoriel, il est effectivement un peu compliqué car, vous vous en doutez sans doute, c'est un peu plus qu'un simple "Hello World". C'est en fait un exemple qui illustre le processus de rendu des caractères en utilisant des librairies de polices. Plus techniquement : ce programme montre en fait la méthode d'assignation de la mémoire à la librairie de polices, et le processus dans lequel les caractères sont rendus par la librairie de polices.
Après le chargement des modules de la librairie, ce programme effectue le rendu des caractères et décharge ensuite les modules de la bibliothèque.
Enfin, il copie les résultats qui ont effectué le rendu dans la mémoire de la même taille qu'un buffer frame dans les buffers frame. Après ceci, le programme l'affiche pendant 10 secondes, sans changer le contenu des buffers frame. Les résultats rendus sont alors affichés sur l'écran. Voilà, c'est pour cela que ce petit "Hello World" fait en fait 770 lignes !

Si vous êtes encore là, merci de nous avoir lu et à très bientôt! 

Crédits et remerciements :

• Flatz pour le fichier make_fself.py ;
• Darbness pour m'avoir donné les fichiers du SDK 3.50 ;
• cfwprophet pour son Fake PKG Generator ;
• VV1LD pour PS4HEN.

L’article [PS4] [PC] TUTO - Installer et utiliser le SDK PS4 officiel est apparu en premier sur Custom Protocol.

Utilisation du système de fichiers

A. Présentation du VFS

Comme défini plus haut, un système de fichiers va vous permettre de créer des fichiers et dossiers depuis votre système d'exploitation et vous déplacer, ouvrir, supprimer ces fichiers, dossiers, etc. Comme pour l'instant l'utilisation de Cosmos ne se fait essentiellement que sur machine virtuelle et non sur un support physique, nous allons utiliser ce qu'on appelle un système de fichiers virtuel (VFS) ou comme Wikipédia le définit : "Une couche d'abstraction au-dessus d'un système de fichiers plus concret".

B. Utilisation du VFS

Lancez Visual Studio, créez un projet ou ouvrez votre projet Cosmos C#. Rendez-vous maintenant dans le fichier Kernel.cs.

Initialisation

Avant d'utiliser le système de fichiers virtuel, il va falloir l'initialiser depuis la boucle BeforeRun() de votre projet (voir le premier tutoriel à la partie 2B pour plus d'informations). Voici le code à utiliser :

FS = new Sys.FileSystem.CosmosVFS();
Sys.FileSystem.VFS.VFSManager.RegisterVFS(FS);

Il est bon de savoir que le système de fichiers utilisé par Cosmos ressemble à celui de Windows, chaque lecteur a sa propre lettre et le répertoire par défaut est "0:\" comme "C:\" sur Windows.

La variable dossier_actuel sera par défaut définie par :

string dossier_actuel = "0:\\";

Commande pour créer un fichier

var f = File.Create(dossier_actuel + "\\fichier.txt"); //Créer un fichier pour chemin dossier_actuel\fichier.txt
f.Close();

Commande pour lire un fichier

string texte = File.ReadAllText(dossier_actuel + "\\fichier.txt"); //La variable 'texte' contiendra le texte contenu dans le fichier

Commande pour supprimer un fichier

File.Delete(dossier_actuel + "\\fichier.txt");

Commande pour créer un dossier

FS.CreateDirectory(dossier_actuel + "\\nomdudossier");

Commande pour supprimer un dossier

Directory.Delete(dossier_actuel + "\\dossier", true); // 'true' signifie que le contenu du dossier va être également supprimé

Commande pour se déplacer vers un dossier

if (input.StartsWith("cd ")) //L'utilisateur entre 'cd nomdudossier'
            {
                var newdir = input.Remove(0, 3); //On extrait le nom du dossier
                if (Directory.Exists(dossier_actuel + newdir))
                //On vérifie si le dossier existe.
                {
                    Directory.SetCurrentDirectory(dossier_actuel);
                    dossier_actuel = dossier_actuel + newdir + "\\";
                }
                else
                {
                    Console.WriteLine("Ce dossier n'existe pas !");
                }
            }

Commande pour se déplacer vers un dossier parent (retour)

var dir = FS.GetDirectory(dossier_actuel);
dossier_actuel = dir.mParent.mFullPath;

Commande pour lister les dossiers et fichiers du dossier ouvert

Console.WriteLine("Type\t     Nom");
                foreach (var dir in Directory.GetDirectories(dossier_actuel))
                {
                    Console.WriteLine("<Dossier>\t" + dir);
                }
                foreach (var file in Directory.GetFiles(dossier_actuel))
                {
                    Console.WriteLine("<Fichier>\t" + file);
                }

Commande pour lister les lecteurs disponibles

var vols = FS.GetVolumes();
                Console.WriteLine("Nom\tTaille\tParent");
                foreach (var vol in vols)
                {
                    Console.WriteLine(vol.mName + "\t" + vol.mSize + "\t" + vol.mParent);
                }

Voilà voilà, vous avez pu voir une liste de différentes commandes utiles à la création d'un système d'exploitation, si vous voulez voir l'application réelle de ces commandes, vous pouvez aller voir la méthode InterpredCMD d'un petit système d'exploitation réalisé par mes soins, où ces commandes y sont inscrites (Ctrl + F pour rechercher dans la page ;) ).

C. Exemple d'implémentation du système de fichiers

Maintenant, depuis votre console, vous pouvez implémenter différentes commandes. Voici un algorithme basique qui va pouvoir interpréter les commandes transmises depuis l'utilisateur (comme depuis le CMD sur Windows) et permettre la création et suppression d'un dossier. Ensuite, à vous d'implémenter vos propres commandes !

using System;
using Sys = Cosmos.System;
using System.IO;
using Cosmos.System.FileSystem;
// Ceci permet d'importer des références.
namespace Custom_Protocol
{
    public class Kernel : Sys.Kernel
    {
        string dossier_actuel = "0:\\";
        public CosmosVFS FS { get; private set; }
        protected override void BeforeRun()
        //Ceci est le code exécuté avant l'exécution du programme.
        {
            Console.Clear();
            //Permet de nettoyer la console des logs de démarrage.
            //On met le clavier en français
            Sys.KeyboardManager.SetKeyLayout(new Sys.ScanMaps.FR_Standard());
            //Initialisation du système de fichier.
            FS = new Sys.FileSystem.CosmosVFS();
            Sys.FileSystem.VFS.VFSManager.RegisterVFS(FS);
            //Fin de l'initialisation
            Console.WriteLine("Tutoriel de customprotocol.com");
            Console.WriteLine("Cosmos a demarre avec succes.");
            //Ceci permet d'écrire une ligne.
        }
        protected override void Run()
        //Ceci est le code exécuté pendant l'exécution du programme, il se répétera indéfiniment.
        {
            Console.Write("commande> ");
            //Ceci permet d'écrire une ligne ou l'on peut écrire sur la même ligne.
            var input = Console.ReadLine();
            //Ceci est une variable qui permet de lire le texte écrit par l'utilisateur.
            InterpretCMD(input);
            //Ceci permet de lancer la méthode qui va interpréter la commande (input)
        }
        private void InterpretCMD(string input)
        //Ceci est la méthode qui interprète la commande envoyée (d'où le "string input") 
        {
            if (input.StartsWith("dir -c ")) //Si la commande commence par dir -c
            {
                string dir = input.Remove(0, 7); //On extrait la commande
                if (!Directory.Exists(dossier_actuel + dir)) //Si le dossier n'existe pas (! symbole de négation)
                {
                    FS.CreateDirectory(dossier_actuel + dir); //On créer le dossier
                    Console.WriteLine("Dossier cree !");
                }
                else if (Directory.Exists(dossier_actuel + dir)) //Sinon si le dossier existe alors
                {
                    Console.WriteLine("Le dossier existe deja !");
                    Console.WriteLine("Dossier cree !");
                    FS.CreateDirectory(dossier_actuel + dir + "-1"); //On créer tout de même un dossier avec comme nom 'nomdudossier-1'
                }
            }
            else if (input.StartsWith("dir -r ")) //Si la commande commence par dir -r alors
            {
                string dirr = input.Remove(0, 7); //On extrait le nom du dossier de la commande
                if (Directory.Exists(dossier_actuel + dirr)) //Si le dossier existe alors
                {
                    Directory.Delete(dossier_actuel + dirr, true); //On le supprime
                    Console.WriteLine("Le dossier '" + dirr + "' a ete supprime !");
                }
                else //Si il n'existe pas
                {
                    Console.WriteLine("Le dossier '" + dirr + "' n'existe pas !");
                }
            }
            else if (input == "dir -l") //Si la commande est égale à dir -l
            {
                Console.WriteLine("Type\t     Nom");
                foreach (var dir in Directory.GetDirectories(dossier_actuel)) //On récupere tous les dossiers
                {
                    Console.WriteLine("<Dossier>\t" + dir); //On affiche tous les dossiers
                }
            }
            else if (input == "hello")
            { //Si la commande est égale à hello alors
                Console.WriteLine("Bonjour!"); //Afficher "Bonjour!".
            }
            else if (input == "bye")
            { //Sinon si la commande est égale à bye
                Sys.Power.Shutdown(); //Éteindre le système.
            }
            else
            { //Sinon (si la commande n'est ni hello ni bye)
                Console.WriteLine("Erreur : Commande inconnue"); //Afficher la commande est inconnue.
            }
        }
    }
}

3) Conclusion

À travers ce tutoriel, vous avez pu voir comment utiliser un système de fichiers dans votre projet Cosmos. Amusez-vous, développez et partagez votre projet ! Si vous manquez d'inspiration, voici même une page comprenant plusieurs projets sous Cosmos : Cosmos Projects.

D'autres tutoriels à propos de Cosmos arriveront sur Custom Protocol bientôt, si vous avez besoin de quoi que ce soit vous pouvez poser une question en commentaire ou sur la conversation Gitter du projet Cosmos ! ;)

L’article [Windows] TUTO – [Partie 2] Utilisation du système de fichiers sous Cosmos est apparu en premier sur Custom Protocol.

Ce tutoriel fut mise à jour le 18/05/2017, avec une autre méthode d'installation dev-kit bien plus pratique et efficace ! N'hésitez pas à re-suivre cette procédure au cas où ! 

Une petite présentation de notre support s'impose, comme ce tutoriel est ciblé aux débutants et que je ne suis pas expert en programmation, je vais m'appuyer sur le super, que dis-je, le magnifique projet Cosmos.

Cosmos est un système d'exploitation, ou plutôt un "kit de construction", basé sur SysLinux autour du compilateur IL2CPU (créé par les mêmes développeurs que CosmosOS). COSMOS signifie d'ailleurs C# Open Source Managed Operating System.

Bref, Cosmos n'est donc pas un système d'exploitation à proprement parler, mais plutôt un « kit de création de système d'exploitation ». Cosmos va vous permettre de créer des systèmes d'exploitation sur Visual Studio et en C# (ou Visual Basic). Le véritable point fort de Cosmos réside dans le fait qu'il est intégré à Visual Studio, ce qui va permettre un développement sous Windows accompagné d'éléments essentiels. En effet, Visual Studio (avec Cosmos) va débugger et générer votre OS avant de l'envoyer à une machine virtuelle.

1) Installation de Cosmos (dev-kit)

La dernière version officielle du projet Cosmos étant parue il y a déjà plusieurs années, il va falloir mettre à jour celle que vous avez déjà installée et si ce n'est pas déjà fait, l'installer. Car depuis, il y a eu plusieurs corrections de bugs, d'ajouts, qui améliorent fortement l'expérience utilisateur.

Il existe deux kits pour Cosmos, l'user-kit et le dev-kit. C'est ce dernier que nous allons compiler pour pouvoir profiter des mises à jour (dont beaucoup sur le système de fichiers que nous verrons un peu plus tard :P).

A. Pré-requis

• Un minimum de connaissances en algorithmique (C# ou VB par exemple) ;
• Être sous Windows 7 au minimum ;
• Visual Studio Community 2015 (à télécharger ici) ;
• .NET Framework 4.5 (à télécharger ici) ;
• VMWare Player (version gratuite) (à télécharger ici) ;
• .NET Framework 3.5 SP1, quelques composants requérant cette version (à télécharger ici).
  

B. Installation de Cosmos

Premièrement, commencez par télécharger ce répertoire (cliquez sur le bouton vert 'Clone or Download' puis 'Download ZIP') que je vous ai moi-même concocté, comprenant de nombreux correctifs et quelques ajouts. Décompressez ensuite l'archive ZIP sur votre bureau par exemple ou dans un dossier dédié (parce que c'est plus propre).

Lancez maintenant le fichier "install-VS2015.bat".

Une fois le programme d'installation lancé, il va tout effectuer tout seul et vous pourrez voir les résultats dans cette fenêtre :

L'installation n'a normalement pas dû prendre de temps et si tout s'est bien passé, Visual Studio s'est lancé en ouvrant la solution "Cosmos" (où vous pouvez éditer ou voir le code source si vous êtes curieux) et le programme d'installation affiche alors en vert : Build Complete!

2) Créer son premier OS

A. Création du projet

Lancez Visual Studio, appuyez sur "Nouveau projet...", cette fenêtre se lance alors :

Créez un nouveau projet comme n'importe quel projet C#, mais sélectionnez Cosmos comme type de projet. Vous pouvez ensuite choisir de programmer votre OS en C# ou en Visual Basic (je conseille le C# mais Visual Basic est tout aussi bien).

Renseignez ensuite le nom de votre projet, ici "Custom Protocol". Appuyez ensuite sur "OK".

Oh, diable, du code ! Ne vous inquiétez : tout va être expliqué.

B. Le code

Tout d'abord, on peut remarquer que votre nouveau projet ressemble beaucoup à une application console C # standard.

Pour l'instant, il faudra rester dans "C# Custom Protocol" et non dans "Custom ProtocolBoot".

Le fichier Kernel.cs contient le code d'amorçage et d'exécution de votre OS.

Quant au fichier AssemblyInfos.cs, il contient des informations relatives à votre programme.

Voici le code source de votre OS, j'ai traduit le texte pour plus de compréhension (vous pouvez copier coller celui-là) :

using System;
using System.Collections.Generic;
using System.Text;
using Sys = Cosmos.System;
// Ceci permet d'importer des références.
namespace Custom_Protocol
{
    public class Kernel : Sys.Kernel
    {
        protected override void BeforeRun() 
        //Ceci est le code exécuté avant l'exécution du programme
        {
            Console.Clear();
            //Permet de nettoyer la console des logs de démarrage
            Console.WriteLine("Tutoriel de customprotocol.com");
            Console.WriteLine("Cosmos a démarré avec succès. Tapez une ligne de texte pour la faire revenir."); 
            //Ceci permet d'écrire une ligne
        }
        protected override void Run() 
        //Ceci est le code exécuté pendant l'exécution du programme, il se répétera indéfiniment.
        {
            Console.Write("Votre texte: "); 
            //Ceci permet d'écrire une ligne ou l'on peut écrire sur la même ligne.
            var texteutilisateur = Console.ReadLine(); 
            //Ceci est une variable qui permet de lire le texte écrit par l'utilisateur
            Console.Write("Texte ecrit: ");
            //Ceci écrit une ligne
            Console.WriteLine(texteutilisateur); 
            //Ceci écrit le texte que l'utilisateur a écrit.
        }
    }
}

C. Votre premier boot !

Vous pouvez maintenant appuyer sur le petit bouton vert "Démarrer", il se situe sur la barre du haut de Visual Studio.

Si votre code n'a pas d'erreurs, et si VMWare est bien installé, la génération va commencer. Voici une petite vidéo d'exemple de génération. 

Après que VMWare se soit lancé, vous devriez normalement voir du texte défiler (il correspond à l'initialisation de l'ISO dans VMWare). Et après tout ceci, si vous avez correctement copié-collé le code plus haut, vous devriez obtenir ceci :

Voilà, vous venez de créer la première version de votre premier OS en 32 bits, bravo ! Vous pouvez évidemment continuer à le développer, avec l'aide de plusieurs tutoriels qui vont arriver très bientôt ou de la documentation officielle du projet Cosmos.

L’article [Windows] TUTO – [Partie 1] [MàJ le 18/05/2017] Créer son système d’exploitation avec Cosmos est apparu en premier sur Custom Protocol.

0) Pré-requis

• Une PS Vita en 3.60 avec HENkaku installé ;
• Un PC (Windows de préférence, c’est l’OS que nous utiliserons pour ce tutoriel) ;
• Le gestionnaire d’archives 7zip ou WinRar ;
• Le fichier d'installation de devkitPro ;
• La dernière version du VitaSDK selon votre OS ;
• L'archive de vitahelloworld ;
• Des compétences en C (pour programmer votre homebrew, c’est pas nécessaire pour simplement compiler).

Ce tutoriel sera mis à jour si des personnes souhaitent savoir comment l'installer sur Mac OS ou Linux.

Partie I - Installation des fichiers nécessaires

Commencez par télécharger les fichiers nécessaires. Pour les fichiers du VitaSDK, prenez la version la plus récente correspondant à votre système d'exploitation.

N'oubliez pas de télécharger le fichier d'installation de devkitPro.

1) Installation de devkitPro

Commencer par lancer devkitProUpdater-1.6.0.exe et suivez les étapes d'installations.

Laissez cochées toutes les cases à la première étape, mais pour la deuxième étape, cochez l'option pour supprimer les fichiers téléchargés.

Il nous faudra seulement le Minimal System et le devkitARM pour faire fonctionner le VitaSDK.

Laissez le chemin d'installation par défaut et cliquez sur "Install".

Patientez pendant que le logiciel télécharge et installe les fichiers pour vous. Dès que l’installation est terminée, cliquez sur « Next » puis « Finish ». Si l'installation s'est bien effectuée, vous devriez avoir à la racine de votre disque dur un dossier « devkitPro ».

2) Installation du VitaSDK

Maintenant que cela est fait, décompressez l'archive du VitaSDK. À l'intérieur, vous devriez retrouver ces 4 dossiers (voir image ci-dessous).

Déplacez les 4 dossiers dans "C:\devkitPro\devkitARM" et acceptez de « Remplacer les fichiers dans la destination ».

Maintenant que cela est fait, ne pensez pas que c'est déjà fini. Il nous reste un dernier petit quelque chose.

3) Configuration du système

Cliquez droit sur « Ordinateur » et sélectionnez l’option « Propriétés ». Si vous ne le trouvez vraiment pas, allez dans « Panneau de configuration -> Système et sécurité -> Système ».

Sur la nouvelle fenêtre qui s’ouvre, choisissez à gauche l’option « Paramètres système avancés ».

Sur la nouvelle fenêtre (encore) qui s’ouvre, cliquez sur le bouton tout en bas « Variables d’environnement ».

Une troisième fenêtre (eh beh purée, qu’est-ce qu’il fait chier lui) va être ouverte. Sur celle-ci, 2 listes s’afficheront à vous : « Variables utilisateur pour X » et « Variables système ». Dans cette liste-ci, trouvez la variable « Path » (et non « PATHTEXT » ! D’ailleurs c’est rigolo, quand on le prononce, ça sonne presque « pastèque ». Lol, qu’est-ce qu’on s’marre ici).

Cliquez une fois dessus pour le sélectionner (il sera mis en surbrillance/surligné). Cliquez ensuite sur le bouton « Modifier » juste en bas. Une quatrième fenêtre va être appelée (y en a encore 5 autres, accrochez-vous ! Non j’déconne, c’est la dernière, promis).

Copiez, après le dernier « bin; », ceci (n’oubliez pas le point-virgule à la fin !) :

C:\devkitPro\devkitARM\bin;C:\devkitPro\arm-vita-eabi\bin;

N’oubliez surtout pas d’enregistrer en cliquant sur « OK », puis fermez toutes les fenêtres des propriétés Windows (ouf, enfin). Voilà, le VitaSDK est enfin installé ! Bon maintenant faut tester !

Partie II - Utiliser le VitaSDK

1) Compilation d'un homebrew

Cette partie va vous surprendre par sa durée. Téléchargez le vitahelloworld (voir dans les Pré-requis) de xerpi et décompressez l'archive. Ouvrez le dossier vitahelloworld-master et cliquez sur "Fichier" puis "Ouvrir l'invite de commandes". Tapez simplement « make » et ça compilera tout seul !

Vous pouvez installer le ".VPK" créé et lancer le homebrew que vous avez compilé sur votre console ! 

Vous pourriez vous arrêtez là mais si vous souhaitez créer vos propres applications, il vous faudra installer des librairies supplémentaires.

2) Installation de bibliothèques supplémentaires

Il est parfois intéressant d'ajouter de nouvelles bibliothèques pour avoir de nouvelles fonctions à utiliser. Pour cela, il faut télécharger la librairie en question et la compiler. Cependant, il faudra parfois suivre les instructions données avec la librairie pour réussir la compilation.

Pour vous donner un exemple, nous allons compiler et installer la libftpvita de xerpi. Commencez par téléchargez et extraire les fichiers. Ouvrez le dossier "libftpvita", et cliquez droit tout en maintenant la touche Shift pour sélectionner "Ouvrir l'invite de commandes" (il se peut que cette option n'apparaisse pas, dans ce cas déplacez le dossier "libftpvita" sur votre Bureau). Comme pour compiler un homebrew, écrivez simplement « make ». La librairie est compilée, maintenant, il faut l'installer !

Dans le dossier "libftpvita", un fichier libftpvita.a a été créé. Déplacez-le dans le dossier "C:\devkitPro\arm-vita-eabi\lib". Retournez dans le dossier où la bibliothèque a été compilée et copiez le fichier "ftpvita.h" dans le dossier "C:\devkitPro\arm-vita-eabi\include". Voilà, la librairie est installée ! 

Si vous voulez faire des tests, sachez que les librairies sont souvent accompagnées d'exemples qu'il vous suffit de compiler.

Si vous avez le moindre problème, n'hésitez pas à poser votre question dans la section programmation de notre forum. Si vous voulez lâcher un commentaire de remerciement, c'est aussi possible à la suite de ce tutoriel !  Merci pour votre lecture passionnée !

L’article [PSV] [PSTV] [PC] TUTO - Installer et utiliser le VitaSDK est apparu en premier sur Custom Protocol.

0) Pré-requis

• Une PS Vita ou PS TV compatible avec le hack PSM, c'est-à-dire :
  • Firmware inférieur (strictement) à 3.52 ;
  • PSM Dev Assistant installé (voir ici pour installer celui d'Unity via PKG) ;
  • Une licence PSM+ que vous penserez à renouveler chaque jour (voir étape 2 du tuto) que vous souhaitez utiliser le hack PSM).
• Un PC (Windows de préférence, c'est l'OS que nous utiliserons pour ce tutoriel) ;
• Le gestionnaire d'archives 7zip ou WinRar ;
• Cette archive ;
• Des compétences en C (pour programmer votre homebrew, c'est pas nécessaire pour simplement compiler) ;
• De la patience ;
• Ce tutoriel (lol).

Ce didacticiel sera peut-être mis à jour pour les ordinateurs Mac et GNU-Linux avec l'aide de mon cher @Tuxbot123.

Partie I - Installer les fichiers du PSP2SDK

1) Téléchargement/préparation des fichiers

Si vous avez bien lu tous les pré-requis, vous avez dû télécharger une archive, non ? Bien, extrayez son contenu dans un répertoire sur votre Bureau (de préférence, vous comprendrez pourquoi). Dans notre exemple, nous appellerons ce répertoire "PSP2SDK Installer".

Ensuite, extrayez le contenu de l'archive "devkitARM_r44-win32.exe" dans votre fameux dossier spécial "installation du PSP2SDK" (chez nous appelé PSP2SDK Installer).

Pendant l'extraction un peu longue, profitez-en pour récupérer tous les fichiers nécessaires au fonctionnement du PSP2SDK. Rendez-vous sur cette page, et téléchargez les dernières archives portant ces noms (un petit ctrl+f peut vous aider si vous n'arrivez pas à vous y retrouver) :

• psp2-libs-dirty
• psp2-tools
• psp2-multilib-dirty
• psp2-libgcc

Si vous êtes utilisateur d'un système Windows, veillez à bien choisir les archives portant la mention "mingw32" (pour les "psp2-tools" notamment).

Créez sur votre disque local "C:/" le répertoire "devkitPro", comme ci-dessous, ce sera fait aussi.

L'extraction est enfin terminée ? Bien, déplacez le dossier "dekitARM" qui vient d'apparaître dans votre répertoire "devkitPro".

Créez pour finir un répertoire que vous nommerez "psp2" (en minuscules).

2) Extraction des archives contenant les fichiers

Rendez-vous maintenant sur le dossier "PSP2SDK Installer", où se trouvent toutes nos archives pour rappel. Ouvrez l'archive "psp2-libs-dirty-xxxxxxx.zip" pour trouver l'option "Extraire les fichiers". Choisissez comme dossier de destination :

C:\devkitPro\devkitARM\psp2

Laissez l'extraction s'effectuer, puis vérifiez votre répertoire "psp2". Il doit ressembler à cela :

Bien, on va extraire toutes nos autres archives du coup. Voici une liste présentant dans l'ordre quelle archive ouvrir, puis l'emplacement où extraire son contenu.

• psp2-tools-xxxxxxx-x86_64-w64-mingw32.zip

C:\devkitPro\devkitARM

• psp2-multilib-dirty-xxxxxxx.zip

C:\devkitPro\devkitARM\arm-none-eabi\lib

• psp2-libgcc-x_x_x.zip

C:\devkitPro\devkitARM\arm-none-eabi\lib

3) Le fichier psp2.specs

Téléchargez le fichier psp2.specs ici. Si votre navigateur ne vous le propose pas en téléchargement, cliquez-droit et choisissez "Enregistrez sous" (CTRL+S). Votre ordinateur tentera peut-être de le convertir au format txt, empêchez-le en virant le ".txt" qui dépasse pour n'avoir que psp2.specs et enregistrez (ignorez l'alerte qui vous dira que le fichier risque d'être inutilisable blablabla). Enfin, déplacez ce fichier là-bas :

C:\devkitPro\devkitARM\arm-none-eabi\lib

4) Configuration du système

Cliquez droit sur "Ordinateur" et sélectionnez l'option "Propriétés". Si vous ne le trouvez vraiment pas, allez dans "Panneau de configuration -> Système et sécurité -> Système".

Sur la nouvelle fenêtre qui s'ouvre, choisissez à gauche l'option "Paramètres système avancés".

Sur la nouvelle fenêtre (encore) qui s'ouvre, cliquez sur le bouton tout en bas "Variables d'environnement".

Une troisième fenêtre (eh beh purée, qu'est-ce qu'il fait chier lui) va être ouverte. Sur celle-ci, 2 listes s'afficheront à vous : "Variables utilisateur pour X" et "Variables système". Dans cette liste-ci, trouvez la variable "Path" (et non "PATHTEXT" ! D'ailleurs c'est rigolo, quand on le prononce, ça sonne presque "pastèque". Lol, qu'est-ce qu'on s'marre ici).

Cliquez une fois dessus pour le sélectionner (il sera mis en surbrillance/surligné). Cliquez ensuite sur le bouton "Modifier" juste en bas. Une quatrième fenêtre va être appelée (y en a encore 5 autres, accrochez-vous ! Non j'déconne, c'est la dernière, promis).

Copiez après le dernier "bin;" ceci (n'oubliez pas le point-virgule à la fin !) :

C:\devkitPro\devkitARM\bin;C:\devkitPro\devkitARM\psp2\bin;

N'oubliez surtout pas d'enregistrer en cliquant sur "OK", puis fermez toutes les fenêtres des propriétés Windows (ouf, enfin). Et voilà, le PSP2SDK est installé, ouf ! Le plus gros est fait ! 

Partie II - Compilation d'un homebrew via le PSP2SDK

1) Extraction des archives

Retournons donc faire un petit tour sur notre répertoire spécial "PSP2SDK Installer".

Extrayez les fichiers de l'archive "vitahelloworld-master.zip". 

Extrayez aussi les fichiers de l'archive "MAKE.zip", mais cette fois-ci dans "C:\devkitPro\devkitARM\bin".

On retourne un p'tit coup sur le dossier "vitahelloworld-master", maintenant. Cliquez droit quelque part sur la fenêtre en maintenant "Shift" (mais pas devant l'un des 7 fichiers), et cliquez sur "Ouvrir une fenêtre de commandes ici". 

Vous avez certainement dû créer votre dossier autre part que sur le Bureau. Dans ce cas, pas de problème, vous pouvez tout de même ouvrir l'invite de commandes en faisant "Exécuter" puis en tapant "cmd", ou bien en cherchant "Invite de commande" dans la barre de recherche de votre Windows. Lorsque la fenêtre noire sera apparue, retournez sur votre dossier spécial installation du PSP2SDK, puis copiez (CTRL+C) le chemin qui mène vers lui et enfin tapez dans l'invite de commandes "cd" suivi d'un espace et de votre fameux chemin (CTRL+V). Voilà une petite capture d'écran pour vous expliquer :

Plus qu'à taper "make". C'est tout. Le homebrew sera compilé et prêt à être lancé sur l'un de vos PSM Dev Assistant. Quoi, vous vous attendiez à plus compliqué ? Désolé de vous décevoir ! 

On vérifie notre dossier "vitahelloworld-master" : de nouveaux fichiers ont normalement fait leur apparition, à savoir des fichiers en ".o" ainsi qu'un "xxx.elf" et un autre "xxx-fixup.elf". C'est ce dernier qu'il faudra glisser-déposer sur le homebrew-run.bat de votre dossier "hack PSM" ou "Rejuvenate".

Vous pouvez d'ailleurs tester le Hello World que l'on vous a livré pour l'exemple, il devrait normalement fonctionner à merveille (testé sur le PSM Dev Assistant for Unity).

Mini FAQ

'make' n'est pas reconnu en tant que commande interne ou externe, un programme exécutable ou un fichier de commandes.
arm-none-eabi-gcc.exe: error: psp2.specs: No such file or directory
make: *** [main.o] Error 1

Vérifiez que vous avez bien copié votre fichier psp2.specs dans "C:\devkitPro\devkitARM\arm-none-eabi\lib" et que les fichiers exécutable du "make" se trouvent bien dans "C:\devkitPro\devkitARM\bin". Essayez aussi de copier le fichier psp2.specs dans le dossier de votre homebrew.

collect2.exe: error: Id returned 1 exit status
make: *** [vitahelloworld.ef] Error 1

Essayez de remplacer les anti-slashs "\" du psp2.specs par des slashs normaux "/".

make: psp2-fixup: Command not found
make: *** [vitahelloworld_fixup.elf] Error 127

Vous avez mal extrait votre archive psp2-tools !

Si vraiment vous n'y arrivez pas, je vous fournis mon dossier "devkitPro" à coller dans votre disque local "C:/". Attention néanmoins, le PSP2SDK étant régulièrement mis à jour, si vous consultez ce tutoriel à une date éloignée de celle à laquelle ce tutoriel aura été publié (18 août 2015), il se peut que vous ne puissiez pas jouir des dernières fonctionnalités proposées par la dernière version.

L’article [PSV] [PSTV] [PC] TUTO – Installer et utiliser le PSP2SDK est apparu en premier sur Custom Protocol.

Nous vous l'avions annoncé, gdljjrod et Rober Galarga ont mis à jour leur interpréteur Lua pour PSP dénommé ONELua. Après deux versions réussies, les deux développeurs reviennent aujourd'hui avec une nouvelle version contenant encore une flopée de nouveautés que nous allons découvrir et décortiquer ensemble pour vous permettre de comprendre leur utilisation via des explications, des exemples et des captures d'écran : bref un article signé Custom Protocol.

Optimisations

Commençons tout d'abord par les nouveautés au niveau des optimisations. Le ONELua en version 3 supporte maintenant les PS Vita utilisant le VHBL, pratique pour lancer des homebrews si on possède le jeu (et sa démo) Toukiden: Kiwami (dispo uniquement sr le Store JP) possédant un exploit en 3.51, ou encore l'exploit World of Pool. Ainsi le Lua Player devient pleinement compatible pour tourner sur toutes les PSP mais également sur les PS Vita. Les développeurs ont également ajouté une nouvelle bibliothèque nommée BitOp qui ajoute des opérations binaires sur les nombres. Vous pouvez regarder les fonctions disponibles avec des exemples à cette adresse.

Cette bibliothèque n'a pas été implémentée au ONELua par hasard, en effet, vous trouverez dans l'archive contenant l'interpréteur un exemple vous démontrant comment utiliser une nouvelle fonction permettant de créer des maps avec un simple fichier texte. Il y a seulement deux fonctions mais aux fonctionnalités intéressantes.

map.new(IMAGE tileset, TABLE mapData, NUMBER TileX, NUMBER TileY)
--IMAGE tileset : Image généré via GBA Graphics contenant les textures pour la map
--TABLE mapdata : Map créé via GBA Graphics contenant les informations de la map
--NUMBER TileX : Taille largeur en pixel des textures à découper
--NUMBER TileY : Taille longueur en pixel des textures à découper
--Retourne la map (à stocker dans une variable)
map.blit(MAP map, NUMBER x, NUMBER y)
--MAP map : Map à afficher généré via la fonction map.new
--NUMBER x : Placement sur l'écran en x
--NUMBER y : Placement sur l'écran en y
--Ne retourne rien

On peut soit dans l'exemple fourni créer une map en vue de face mais également en vue de côté. Comme cité dans les fonctions, il vous faudra obligatoirement utiliser le logiciel GBA Graphics 1.09 disponible certes en anglais mais aussi en français !

Voici quelques exemples postés par plusieurs développeurs des possibilités de ces fonctions.

En exemple, pour utiliser cette fonction, vous pouvez vous référer au contenu de l'archive du ONELua où le code a été commenté par @applelo1 (moi même) en français.

Fonctions images

Passons ensuite aux fonctions images, où nous avons le droit à une ribambelle de nouveautés. Nous avons enfin la possibilité de charger les images dans la VRAM (mémoire vidéo) via la fonction image.loadv() pour un affichage plus rapide de celles-ci (pour des sprites par exemple) mais plus limité en mémoire que la RAM (mémoire vive). Il est aussi possible de "déplacer" une image de la VRAM à la RAM et inversement en utilisant la fonction image.move().

Désormais, via la fonction image.loadfromdata(), les images converties en données binaires peuvent être chargées, utile pour charger les images disponibles sur internet permettant un gain de rapidité. Un petit exemple s'impose pour vous montrer :

local fp = io.open("monimg.png","rb")--J'ouvre l'image comme si s'était un fichier
local databin = fp:read("*a")--Je lis le contenu du fichier
fp:close()--Je ferme la lecture du fichier
monimg = image.loadfromdata(databin,__PNG)--La fonction charge et transforme les données binaires en fichiers
while true do--J'ouvre ma boucle
image.blit(monimg,0,0) --J'affiche mon image
screen.flip()--Je rafraichie l'écran
end--Je ferme la boucle

Et c'est pas fini, puisqu'on peut également modifier ses images via trois nouvelles fonctions ! La première, image.blitadd(), permet d'afficher l'image en y ajoutant un effet de couleur alors que la deuxième, image.blitsub(), au contraire, permet de supprimer la couleur. La dernière quant à elle, image.blittint(), permet d'afficher une image et de la teindre également d'une couleur.

Voici le récapitulatif de toute les nouvelles fonctions concernant les images retranscrit ici.

image.loadv(STRING path)
image.loadv(STRING path, COLOR mask)
image.loadv(STRING path, NUMBER w, NUMBER h)
image.loadv(STRING path, NUMBER w, NUMBER h, COLOR mask)
--STRING path : Chemin de l'image
--COLOR mask : Masque de couleur à appliquer à l'image
--NUMBER w : Largeur pour couper les sprites
--NUMBER h : Hauteur pour couper les sprites
--Retourne une image, prête à être utiliser.
image.move(IMAGE img)
--IMAGE img : Variable de l'image
--Ne retourne rien
image.loadfromdata(STRING data, NUMBER type)
--STRING data : Donnée de l'image en fichier binaire
--NUMBER type : 
---------------__PNG (0) pour image en .png
---------------__JPG (1) pour image en .jpg
---------------__GIF (2) pour image en .gif
image.blitadd(IMAGE img,NUMBER x,NUMBER y,NUMBER coef)
--IMAGE img : Variable de l'image
--NUMBER x : Placement sur l'écran en x
--NUMBER Y : Placement sur l'écran en y	
--NUMBER coef : Niveau d'ajout de couleur (entre 0 et 255)
--Ne retourne rien
image.blitsub(IMAGE img,NUMBER x,NUMBER y,NUMBER coef)
--IMAGE img : Variable de l'image
--NUMBER x : Placement sur l'écran en x
--NUMBER Y : Placement sur l'écran en y	
--NUMBER coef : Niveau de suppression de couleur (entre 0 et 255)
--Ne retourne rien
image.blittint(IMAGE img,NUMBER x,NUMBER y,COLOR color)
--IMAGE img : Variable de l'image
--NUMBER x : Placement sur l'écran en x
--NUMBER Y : Placement sur l'écran en y	
--COLOR color : Couleur pour teindre l'image
--Ne retourne rien

Le ONELua se montre aussi très performant comme gestionnaire des EBOOT.PBP, 3 nouvelles fonctions font ainsi leur entrée avec cette troisième version par ce que l'on appelle leurs callbacks. La fonction game.pack() permet de créer un EBOOT si vous disposez d'un dossier contenant toutes les ressources nécessaires (PARAM.SFO, ICON0.PNG...). Ensuite, game.add() permet d'ajouter ou remplacer un fichier alors que la fonction game.remove() permet finalement de supprimer un fichier contenu dans l'EBOOT.PBP.

Fonctions TV

Vous devriez savoir, puisque nous vous l'avions déjà annoncé, que le ONELua intègre désormais des fonctions liées à la télévision, la première étant de pouvoir retransmettre l'écran de la PSP vers l'écran d'une télé si vous disposez d'un adaptateur. Il est possible notamment de régler via cette fonction la qualité de la retransmission. Attention, il vous faudra impérativement le dvemgr.prx contenu dans l'archive pour pouvoir faire fonctionner la fonction. La deuxième, os.cabletv(), permet de reconnaître si votre PSP est branchée à un écran externe ainsi que le type de câble utilisé.

os.modetv(NUMBER quality)	
--Active la retransmission
--NUMBER quality : La qualité de retransmission
--------------------__8888 (32 bits RGBA)
--------------------__4444 (16 bits R4G4B4A4)
--------------------__5551 (16 bits R5G5B5A1)
--------------------__5650 (16 bits R5G5B5, pas de chaîne alpha)
--Ne retourne rien
os.modetv()
--Désactive la retransmission
--Ne retourne rien
os.cabletv()	
--Reconnait le cable utilisé
--Retourne un nombre
--0 si aucun cable n'est connecté
--1 si c'est un cable S-Video/AV (composite)
--2 si c'est un cable D Terminal Cable/Component Cable

Fonction windows

En plus de cela, une nouvelle fonction vient de faire son apparition, et nommée os.messagebox(). Elle permet d'afficher une boîte de dialogue (ressemblant beaucoup à celle de Windows) avec des possibilités de personnalisation. On peut par exemple entrer le titre et le message de son choix, ainsi que choisir entre 1 à 4 boutons associés à des actions simples (Oui, Non, Quitter, Annuler, Ok) mais malheureusement qui ne sont pas paramétrables et en anglais. Voici l'exemple fourni par les auteurs avec les commentaires traduits en français :

option = {"OK","CANCEL","YES","NO",""}--Table des réponses
--La variable ou est reçu les réponses de la fonction os.messagebox()
local response = 5
local title = "Test Of Box" -- Titre
local msg = "Hello From Box...\nOK = 1\nCANCEL = 2\nYES = 3\nNO = 4\nEXIT = 5" -- Message
while true do
    buttons.read() -- Lecture des touches pressés
    if buttons.triangle then -- Pressez /\
	-- Montre deux boutons X:OK, O:CANCEL par défaut
		response = os.messagebox(title,msg)
    elseif buttons.circle then --Pressez O
	-- Montre le bouton 0:EXIT
        response = os.messagebox(title,msg,__CIRCLE,__EXIT)
    elseif buttons.cross then--Pressez X
	-- Montre deux boutons avec L: No, R: Yes
		response = os.messagebox(title,msg,__L,__NO,__R,__YES)
    elseif buttons.square then -- Pressez []
	-- Montre trois boutons avec L: No, R: Yes X: YES, O: NO, /\: Exit
		response = os.messagebox(title,msg,__CROSS,__YES,__CIRCLE,__CANCEL,__TRIANGLE,__EXIT)
    end
    screen.print(10,5,"Example Message Box")
	
	screen.print(10,17,"Presez triangle pour un simple Message Box (X:OK, O:CANCEL)",0.6)
	screen.print(10,32,"Pressez rond pour un Message Box (O:EXIT)",0.6)
	screen.print(10,47,"Pressez croix pour un Message Box (L:NO, R:YES)",0.6)
	screen.print(10,62,"Pressez carré pour un Message Box (X:YES, O:CANCEL, triangle:EXIT)",0.6)
    -- Nous affichons la valeur pour telle action :)
	screen.print(10,200,"Résultat: "..response.." Selection: "..option[response])
    screen.flip() -- Rafraîchissement de l'écran
end
	

De plus, impossible de personnaliser l'apparence des boutons et de la boîte de dialogue. Espérons une mise à jour pour pouvoir personnaliser d'avantage cette petite fonction bien sympathique.

os.messagebox(STRING title,STRING mje)
--STRING title : Le titre de la boîte de dialogue
--STRING mje : Le message à mettre dans la boîte de dialogue
--Retourne 1 si la réponse est OK (quand vous pressez X) ou bien 2 quand vous choisissez CANCEL (quand vous pressez O)
os.messagebox(STRING title,STRING mje,NUMBER button1,NUMBER assigned1)
--STRING title : Le titre de la boîte de dialogue
--STRING mje : Le message à mettre dans la boîte de dialogue
--NUMBER button1 : Le bouton à inscrire (par exemple __CIRCLE, __UP, __L)
--NUMBER assigned1 : L'action à assigner __OK, __CANCEL, __YES, __NO, __EXIT
--Retourne 1 si l'action est __OK, 2 si __CANCEL, 3 si __YES, 4 si __NO et 5 si __EXIT
os.messagebox(STRING title,STRING mje,NUMBER button1,NUMBER assigned1,NUMBER button2,NUMBER assigned2)
--STRING title : Le titre de la boîte de dialogue
--STRING mje : Le message à mettre dans la boîte de dialogue
--NUMBER button1 : Le bouton à inscrire (par exemple __CIRCLE, __UP, __L)
--NUMBER assigned1 : L'action à assigner __OK, __CANCEL, __YES, __NO, __EXIT
--NUMBER button2 : Le bouton à inscrire (par exemple __CIRCLE, __UP, __L)
--NUMBER assigned2 : L'action à assigner __OK, __CANCEL, __YES, __NO, __EXIT
--Retourne 1 si l'action est __OK, 2 si __CANCEL, 3 si __YES, 4 si __NO et 5 si __EXIT
os.messagebox(STRING title,STRING mje,NUMBER button1,NUMBER assigned1,NUMBER button2,NUMBER assigned2,NUMBER button3,NUMBER assigned3)
--STRING title : Le titre de la boîte de dialogue
--STRING mje : Le message à mettre dans la boîte de dialogue
--NUMBER button1 : Le bouton à inscrire (par exemple __CIRCLE, __UP, __L)
--NUMBER assigned1 : L'action à assigner __OK, __CANCEL, __YES, __NO, __EXIT
--NUMBER button2 : Le bouton à inscrire (par exemple __CIRCLE, __UP, __L)
--NUMBER assigned2 : L'action à assigner __OK, __CANCEL, __YES, __NO, __EXIT
--NUMBER button3 : Le bouton à inscrire (par exemple __CIRCLE, __UP, __L)
--NUMBER assigned3 : L'action à assigner __OK, __CANCEL, __YES, __NO, __EXIT
--Retourne 1 si l'action est __OK, 2 si __CANCEL, 3 si __YES, 4 si __NO et 5 si __EXIT

Fonctions écran

Continuons sur une nouvelle fonction qui ravira toute personne qui ne souhaiterait pas utiliser le grand écran de la PSP : la fonction screen.clip(). Vous l'aurez deviné, elle permet de n'afficher qu'une partie de l'écran déterminable avec la fonction.

screen.clip(NUMBER x,NUMBER y, NUMBER w, NUMBER h)
--Active la délimitation d'affichage à l'écran
--NUMBER x : Position sur l'axe x 
--NUMBER y : Position sur l'axe y
--NUMBER w : Largeur
--NUMBER h : Hauteur
--Ne retourne rien
screen.clip()
--Désactive la délimitation d'affichage à l'écran
--Ne retourne rien

Fonctions texte

Le développeur a également ajouté une fonctionnalité déjà présente dans plusieurs Lua Players : la fonctionnalité permettant de faire défiler un texte. Disponible maintenant avec la fonction screen.print(), il est ainsi possible de réaliser "un scroll" du texte de gauche à droite, de droite à gauche, de droite à gauche puis de gauche à droite et...

-- ## Example Scroll Print ##
-- Nous assignors des variables pour les valeurs X permettrons le daplacement du texte
scrollx1 = 10 -- axe pour déplacement vers la gauche (droite vers gauche)
scrollx2 = 450 -- axe pour déplacement vers la droite (gauche vers droite)
scrollx3 = 240 -- axe pout déplacement de la droite vers la gauche (droite vers la gauche sans disparition)
scrollx4 = 240 -- gauche droite puis droite gauche (centré)
--Charge la palette de couleur
color.loadpalette()
while true do--On ouvre la boucle
	draw.line(240,0,240,272,color.red) --Nous traçons une ligne vertical rouge au milieu de l'écran
	--[[La variable précédente assigné à l'axe x est passé comme un argument et ergot le résultat de la fonction et s'ajoute à cela l'argument "w" pour régler l'affichage de la zone de texte.]]
	--__SLEFT est comme un alignement vers la gauche affiché à partir de l'axe x vers la droite avec un espace d'affichage de 90.
	scrollx1 = screen.print(scrollx1,10,"test scroll gauche",0.7,color.white,color.black,__SLEFT,90)
	--__SRIGHT est comme un alignement vers la droite affiché à partir de l'axe x vers la gauche avec un espace d'affichage de 100.
	scrollx2 = screen.print(scrollx2,25,"test scroll right",0.7,color.white,color.black,__SRIGHT,100)
	-- __STHROUGH est comme un alignement vers la gauche qui est affiché à partir de l'axe x vers la droite avec un espace d'affichage de 100. 
	scrollx3 = screen.print(scrollx3,50,"test scroll throuh",0.7,color.white,color.black,__STHROUGH,100)
	--[[__SSEESAW est un alignement au centre affiché sur l'axe x - moitié de l'espace pour l'afficher,
du droite centrer à gauche centré avec un espace d'affichage de 100
	Note: Si ce mode n'a pas d'effet, c'est pour les raison précedemment cité, alors il effete normalement un texte aligné à gauche.]]
	scrollx4 = screen.print(scrollx4,70,"test scroll seesaw",0.7,color.white,color.black,__SSEESAW,100)
	screen.flip() --Rafraichissement de l'écran
end--Fin de la boucle
	

Concernant toujours la fonction gérant l'affichage de texte, il est maintenant possible de pouvoir justifier le texte en plus d'aligner à droite, à gauche ou bien au centre.

Fonction contrôle

L'une des dernières principales nouveautés dont nous allons vous parler concerne les contrôles : qui n'a jamais trouvé cela fatigant dans un homebrew de devoir appuyer plusieurs fois sur "Haut" ou "Bas" pour naviguer dans un long menu ? Ce n'est clairement pas pratique, mais gdljjrod et Rober Galarga ont trouvé une solution : la fonction buttons.interval(). Elle permet tout simplement de simuler le fait de rappuyer sur une touche, tout cela étant paramétrable que ce soit le temps d'activation ou le temps entre chaque répétition. Cette fonction ne fonctionne évidemment pas si vous avez choisi que l'action effectuée doit être "maintenir appuyer le bouton".

buttons.interval(NUMBER delay,NUMBER interval)
--Active la fonction
--NUMBER delay : Le délai en cycle avant l'activation (valeur conseillé 40)
--NUMBER interval : L'interval de répétition en cycle (valeur conseillé 10)
--Ne retourne rien
buttons.interval()
--Désactive la fonction
--Ne retourne rien

Autres fonctions

Dans les ajouts mineurs, on retrouve plusieurs petites nouveautés. Tout d'abord, la fonction amg.screenshot() a été ajoutée et permet, comme vous l'aurez sans doute deviné, de prendre une capture d'écran lorsque vous utilisez la librairie AMG spécialisée dans la 3D. Ensuite, les fonctions timers.new et timer.reset retournent la valeur initiale, et la fonction os.cfw() reconnait si l'utilisateur utilise le VHBL. Enfin, la fonction ini.read() peut maintenant lire jusqu'à 1024 caractères. Le développeur a amélioré par ailleurs les performances et corrigé des bugs notamment celui concernant la fonction screen.textheight().

Comme vous pouvez le constater, le ONELua version 3 est l'aboutissement d'un long travail de ces développeurs qui incluent des nouveautés de plus en plus ambitieuses. En espérant qu'ils ne s'arrêtent pas de si tôt !

Pour finir ce long article en beauté, on va conclure comme dans notre dernier article sur une superbe vidéo montrant les capacités de ce Lua Player. Mise en ligne par gljjrod, il s'agit d'une capture vidéo de la démo réalisée par Mills (développeur connu notamment pour son jeu Space Ball) baptisée Fruit Explosion, que nous vous conseillons de télécharger que vous soyez développeur ou pas pour admirer les capacités de notre bonne vielle PSP.

L’article [PSP] [Vita] Le ONELua de nouveau mis à jour est apparu en premier sur Custom Protocol.

Vous visitez actuellement un de nos cours pour programmer en Lua. Pour voir la liste des cours disponibles sur le site, cliquez ici.

Nous allons apprendre dans ce cours à maitriser les touches de la PSP, ce qui va nous permettre de créer vos propres programmes de manière guidé (bientôt dans un Travail Pratique). Nous n'en sommes pas encore là, mais si vous persévérez, je suis sur que vous allez y arriver sans problème, en suivant bien le cours que nous allons aborder ;)

Tout d'abord, il va falloir stocker du texte, on pourrait créer des variables mais nous allons réutiliser le cours d'avant pour pouvoir réaliser notre programme. Nous allons donc utiliser des tables qui contiendront des informations par rapport à la touche pour ensuite les afficher sur l'écran de la PSP. Par exemple, je reste appuyé sur la touche croix, donc ma PSP affichera que j'appuie sur la touche croix.

Donc on crée une table contenant toutes les informations nécessaires...

table = {}--Création d'une table regroupant toutes les infos suivantes
table[1] = "Appuie sur la touche Croix"
table[2] = "Appuie sur la touche Triangle"
table[3] = "Appuie sur la touche Carré"
table[4] = "Appuie sur la touche Rond"
table[5] = "Appuie sur la touche Haut"
table[6] = "Appuie sur la touche Droite"
table[7] = "Appuie sur la touche Gauche"
table[8] = "Appuie sur la touche Bas"
table[9] = "Appuie sur la touche R"
table[10] = "Appuie sur la touche L"
table[11] = "Appuie sur la touche START"
table[12] = "Appuie sur la touche SELECT"

 Nous n'aborderons pas le stick analogique qui sera abordé dans un cours pour réaliser un menu avec curseur.

Très bien maintenant nous pouvons mettre notre boucle while true do.

while true do

 Et nous allons rajouter ensuite la fonction suivante qui va permettre de lire les boutons qui sont actionnés dans le programme à chaque début de la boucle.

buttons.read()--Lecture des touches actionnées

Maintenant nous allons utiliser pour la première fois une condition. Nous voulons afficher tel texte pour tel touche de la PSP, donc si je reste appuyer sur la touche croix alors j'affiche le texte "Appuie sur la touche Croix".

Ce qui donnera en Lua :

if buttons.held.cross then--Si je reste appuyé sur la touche croix alors
 screen.print(5,10,table[1])--J'affiche le texte adéquat
end--Fin de la condition

Puis on fait la même chose pour toute les touches de la PSP.

if buttons.held.triangle then--Si je reste appuyé sur la touche triangle alors
  screen.print(5,20,table[2])--J'affiche le texte
end--Fin de la condition
if buttons.held.square then--Si je reste appuyé sur la touche carré alors
  screen.print(5,30,table[3])--J'affiche le texte
end--Fin de la condition
if buttons.held.circle then--Si je reste appuyé sur la touche rond alors
  screen.print(5,40,table[4])--J'affiche le texte
end--Fin de la condition
if buttons.held.up then--Si je reste appuyé sur la touche haut alors
  screen.print(5,50,table[5])--J'affiche le texte
end--Fin de la condition
if buttons.held.right then--Si je reste appuyé sur la touche droite alors
  screen.print(5,60,table[6])--J'affiche le texte
end--Fin de la condition
if buttons.held.left then--Si je reste appuyé sur la touche gauche alors
  screen.print(5,70,table[7])--J'affiche le texte
end--Fin de la condition
if buttons.held.down then--Si je reste appuyé sur la touche bas alors
  screen.print(5,80,table[8])--J'affiche le texte
end--Fin de la condition
if buttons.held.r then--Si je reste appuyé sur la touche R alors
  screen.print(5,90,table[9])--J'affiche le texte
end--Fin de la condition
if buttons.held.l then--Si je reste appuyé sur la touche L alors
  screen.print(5,100,table[10])--J'affiche le texte
end--Fin de la condition
if buttons.held.start then--Si je reste appuyé sur la touche Start alors
  screen.print(5,110,table[11])--J'affiche le texte
end--Fin de la condition
if buttons.held.select then--Si je reste appuyé sur la touche Sélect alors
  screen.print(5,120,table[12])--J'affiche le texte
end--Fin de la condition

Voilà maintenant il ne reste plus qu'à rafraichir l'écran à chaque fin de tour de notre boucle et fermer la boucle while true do.

screen.flip()--Rafraichissement de l'écran
end--Fin de la boucle

 Voilà normalement vous devez obtenir ceci :

Voilà le code en entier:

table = {}--Création d'une table regroupant toutes les infos suivantes
table[1] = "Appuie sur la touche Croix"
table[2] = "Appuie sur la touche Triangle"
table[3] = "Appuie sur la touche Carré"
table[4] = "Appuie sur la touche Rond"
table[5] = "Appuie sur la touche Haut"
table[6] = "Appuie sur la touche Droite"
table[7] = "Appuie sur la touche Gauche"
table[8] = "Appuie sur la touche Bas"
table[9] = "Appuie sur la touche R"
table[10] = "Appuie sur la touche L"
table[11] = "Appuie sur la touche START"
table[12] = "Appuie sur la touche SELECT"
while true do--Début de la boucle
	
	buttons.read()--Lecture des touches actionnées
	
	if buttons.held.cross then--Si je reste appuyé sur la touche croix alors
		screen.print(5,10,table[1])--J'affiche le texte adéquat
	end--Fin de la condition
	
	if buttons.held.triangle then--Si je reste appuyé sur la touche triangle alors
	  screen.print(5,20,table[2])--J'affiche le texte
	end--Fin de la condition
	
	if buttons.held.square then--Si je reste appuyé sur la touche carré alors
	  screen.print(5,30,table[3])--J'affiche le texte
	end--Fin de la condition
	
	if buttons.held.circle then--Si je reste appuyé sur la touche rond alors
	  screen.print(5,40,table[4])--J'affiche le texte
	end--Fin de la condition
	
	if buttons.held.up then--Si je reste appuyé sur la touche haut alors
	  screen.print(5,50,table[5])--J'affiche le texte
	end--Fin de la condition
	
	if buttons.held.right then--Si je reste appuyé sur la touche droite alors
	  screen.print(5,60,table[6])--J'affiche le texte
	end--Fin de la condition
	
	if buttons.held.left then--Si je reste appuyé sur la touche gauche alors
	  screen.print(5,70,table[7])--J'affiche le texte
	end--Fin de la condition
	
	if buttons.held.down then--Si je reste appuyé sur la touche bas alors
	  screen.print(5,80,table[8])--J'affiche le texte
	end--Fin de la condition
	
	if buttons.held.r then--Si je reste appuyé sur la touche R alors
	  screen.print(5,90,table[9])--J'affiche le texte
	end--Fin de la condition
	
	if buttons.held.l then--Si je reste appuyé sur la touche L alors
	  screen.print(5,100,table[10])--J'affiche le texte
	end--Fin de la condition
	
	if buttons.held.start then--Si je reste appuyé sur la touche Start alors
	  screen.print(5,110,table[11])--J'affiche le texte
	end--Fin de la condition
	
	if buttons.held.select then--Si je reste appuyé sur la touche Sélect alors
	  screen.print(5,120,table[12])--J'affiche le texte
	end--Fin de la condition
	
	screen.flip()--Rafraichie l'écran
	
end--Fin de la boucle while
		

Maintenant que vous savez utiliser les touches de votre PSP, vous allez pouvoir commencer sérieusement à penser à des projets mais pour cela, il faudra encore apprendre de nouvelle chose  

L’article Programmer en Lua - Débutant - Cours n°5 : Les touches de la PSP est apparu en premier sur Custom Protocol.

 Vous visitez actuellement un de nos cours pour programmer en Lua. Pour voir la liste des cours disponibles sur le site, cliquez ici.

Nous allons rentrer dans un cours plus théorique que ceux abordé avant, soyez attentif car cela vous servira pour tous les cours et projets en Lua.

Une table, c'est comme un peu près un tableau de valeur sur excel. Vous pouvez ranger dans une table plusieurs valeurs de type string ou des nombres ou bien des fonctions.

Commençons par l'utilisation de base d'une table, imaginons que j'ai trois images de 10*10 pixels, que j'ai envie d'afficher sur mon écran de PSP de façon simple et intelligente, je devrais utiliser des tables. Tout d'abord soit j'ajoute directement mes données dans une table, soit je crée et j'ajoute une part une mes données.

table = {
image.load("1.png"),--je charge ma première image dans la case 1, 
image.load("2.png"),--puis la deuxième dans la case 2 
image.load("3.png")--et pour finir la troisième image dans la case 3.
}

table = {}--Je crée ma table
table[1] = image.load("1.png")--je charge ma première image dans la case 1
table[2] = image.load("2.png")--je charge ma deuxième image dans la case 2
table[3] = image.load("3.png")--ke charge ma troisième image dans la case 3

 Puis on utilise une boucle while true do 

while true do--Début de la boucle

 Maintenant, nous allons utiliser une boucle for de ce type :

for i=1,3 do--Début de la boucle for

 Cette boucle ce répète trois fois, la valeur i prend ainsi la valeur 1, 2 et 3. Nous pouvons donc "jouer" avec cette boucle qui est très pratique pour naviguer dans une table, on peut l'utiliser aussi par exemple pour faire des menus optimisés(voir dans un autre cours) ou dans bien d'autre cas adéquat à son utilisation.

Nous allons donc afficher les trois images sur l'écran de notre PSP avec la fonction vu dans le cours numéro 3.

image.blit(table[i],(i*20),10)--Affichages des images

 Ainsi on affiche l'image 1, 2 et 3 situé leur case respective et on multiplie par 20 la position X(horizontal) de l'image pour ne pas superposer les 3 images et vu que nos images font 10*10 pixels, ce qui laisse un espace de 10 pixels entre chaque image.

Nous pouvons donc fermer notre boucle for ainsi que finir par rafraichir l'écran et fermer notre boucle while.

end--Fin de la boucle for
screen.flip()--Rafraichie l'écran
end--Fin de la boucle while

Voilà c'est terminé, comme je suis gentil, j'ai préparé trois images de tailles 10*10 pixels.

table = {}--Je crée ma table
table[1] = image.load("1.png")--je charge ma première image dans la case 1
table[2] = image.load("i2.png")--je charge ma deuxième image dans la case 2
table[3] = image.load("3.png")--je charge ma troisième image dans la case 3
while true do--Début de la boucle
	
	for i=1,3 do--Début de la boucle for
		
		image.blit(table[i],(i*20),10)--Affichages des images
		
	end--Fin de la boucle for
	screen.flip()--Rafraichie l'écran
end--Fin de la boucle while

 Voici le résultat que vous devez normalement obtenir sur votre PSP :

Vous savez maintenant les bases à propos des tables, si vous voulez allez toujours plus loin par rapport au table rendez vous dans un autre cours dans une section plus exigeante.

L’article Programmer en Lua – Débutant – Cours n°4 : Abordons les tables est apparu en premier sur Custom Protocol.

Vous visitez actuellement un de nos cours pour programmer en Lua. Pour voir la liste des cours disponibles sur le site, cliquez ici.

Vous savez maintenant afficher du texte sur votre PSP, maintenant il va falloir afficher une image. Certains passages que nous avons vu dans le dernier cours ne serons donc pas repris.

Tout d'abord, nous allons ajouter une variable. Une variable permet d'enregistrer des nombres, des strings(voir le deuxième cours) mais aussi enregistrer des valeurs retournés par certaines fonctions. Ici, nous allons utiliser la fonction suivante :

image.load()

Cette fonction ci-dessus permet de charger une image au format .png, .jpg ou bien .gif. Attention, on ne peut pas charger des images supérieur à 512*512 pixels et les animations des images au format .gif ne sont pas supportés.

Pour notre cours nous allons utiliser l'image ci-dessous: faites clique droit, enregistrez sous..., et placez la dans le dossier ou se trouve le script.lua et l'EBOOT.PBP. Nous utilisons une image blanche car il faut savoir que le reste de l'écran sera noir...

Vous devriez normalement avoir tous ces fichiers présents dans votre dossier.

Très bien, passons au chose sérieuse, ouvrez donc votre fichier script.lua si cela n'est pas déjà fait et commencez par charger l'image dans la mémoire RAM(mémoire temporaire) de votre PSP.

notreimage = image.load("logo.png")--Chargement de l'image

Maintenant la variable notreimage contient l'image "logo.png".

Ensuite nous faisons comme dans le deuxième cours, on crée une boucle while true do.

while true do--Début de notre boucle

Puis on affiche  l'image sur l'écran de votre PSP avec la fonction suivante :

image.blit(image,x,y)

Comme avec la fonction d'affichage de texte, nous allons mettre notre variable, puis la position X et Y où nous voulons placer notre image sur l'écran de la PSP. Ce qui donnera :

image.blit(notreimage,100,100)--Affiche l'image

Puis on rafraîchie l'écran et on ferme la boucle.

screen.flip()--Rafraichissement de l'écran
end--Fin de la boucle

Enregistrez votre fichier script.lua et lancer votre programme depuis votre PSP, vous devrez normalement obtenir ceci :

Code en entier:

notreimage = image.load("logo.png")--Chargement de l'image
while true do--Début de la boucle
image.blit(notreimage,100,100)--Affichage de l'image
screen.flip()--Rafraichissement de l'écran
end--Fin de la boucle

Vous pourrez retrouvez dans d'autre section, des usages plus complexes des fonctions liés aux images, n'hésitez pas à y jeter un coup d'oeil si vous avez le niveau adéquate ;)

L’article Programmer en Lua – Débutant – Cours n°3 : Afficher une image est apparu en premier sur Custom Protocol.

Vous visitez actuellement un de nos cours pour programmer en Lua. Pour voir la liste des cours disponibles sur le site, cliquez ici.

Vous êtes enfin prêt à coder en Lua, restez attentif tout au long du cours car certaine fonction de base que nous allons voir vous resservirons dans les autres tutoriels.

Avant de commencer sachez que vous pouvez mettre du commentaire, c'est à dire que les passages ne seront pas pris en compte lors de la lecture par l'interpréteur. Très pratique pour commenter son code comme je vais le faire dans mes cours ;)

--Juste avec ces deux tirets je commente mon code
--Tout simplement ;)

Ouvrez donc tout d'abord votre fichier script.lua (qui est dans le pack du dernier cours) avec le logiciel Atom ou un autre éditeur syntaxique de votre choix.

On y va ?

Tout d'abord on va créer une boucle while true do, c'est à dire qu'on va répéter tous le temps l'action d'afficher le texte à l'écran ici.

while true do--Début de ma boucle

Puis nous allons utiliser la fonction

screen.print(x,y,"Votre texte")--Affichage du texte

X et Y(comme en cours de math) est la position de votre texte sur votre écran. Il faut savoir que la PSP a un écran de 480*272 donc il ne faut pas dépasser ces valeurs si vous voulez voir votre texte sur l'écran de votre PSP.

Il vous suffit ensuite rentrer votre texte, ici "Hello World!" entre guillemet, on dira plutôt string en langage informatique.

Nous allons ensuite rafraichir l'écran avec la simple fonction qui ce met à la fin de votre boucle.

screen.flip()--Rafraichissement de l'écran

Puis on ferme la boucle.

end--Fin de ma boucle

Il ne vous reste plus qu'à enregistrer, transférer le dossier sur votre PSP puis à lancer votre premier programme pour voir apparaitre ceci : 

Code en entier:

while true do--Début de ma boucle
screen.print(100,100,"Hello World!")--Affichage du texte
screen.flip()--Rafraichissement de l'écran
end--Fin de ma boucle

Si vous voulez approfondir l'affichage de texte sur PSP, avec de la couleur, des effets... rendez vous dans la section Apprenti ;)

L’article Programmer en Lua – Débutant – Cours n°2 : Afficher du texte (Hello World !) est apparu en premier sur Custom Protocol.