Pour rappel, le but d'un Lua Player est de faire tourner le langage Lua. De plus, il y apporte des fonctions pour accéder aux fonctionnalités de l'appareil. L'avantage du ONELua est la facilité de créer un homebrew pour PSP et PS Vita.

Dans cette quatrième version du ONELua, le nombre de nouveautés est conséquente. On retrouve de nouvelles fonctions pour le module caméra, le module jeu et la gestion des Custom Themes. Mais aussi, ce qui pouvait faire défaut avant, un travail conséquent sur l'optimisation du code et de la correction de bugs.

Si vous aviez un programme qui utilisait une version antérieure au ONELua v4, nous vous conseillons de lire la documentation. En effet, l'équipe a fait beaucoup de changements, au niveau des noms de certaines constantes par example.

Notre principal regret, c'est que l'équipe derrière le ONELua ne fournit toujours pas le code source. Ce qui est bizarre quand on met une licence GPL v3 sur son dépot Git... Dans les autres points négatifs, on peut noter le manque de personnalisation sur certaines fonctions, notamment sur tout ce qui concerne la communication avec un service web.

Le ONELua, dans cette quatrième monture, est sûrement le meilleur Lua Player pour PS Vita à l'heure actuelle. Néanmoins, il ne faut pas s'attendre à voir une nouvelle version majeure de celui-ci débarquer dans les mois à venir. En effet, la communauté de développeurs sur PS Vita disparaît petit à petit et peu de personnes continuent le portage des fonctions natives du SDK de Sony vers le VitaSDK...

Mais si vous voulez coder un jeu, un utilitaire ou tout simplement vous amuser, cela reste un excellent choix pour développer sur PS Vita !

L’article [Vita] Le ONELua se met à jour dans une quatrième version est apparu en premier sur Custom Protocol.

Aujourd'hui, les développeurs gdljjrod, Davis et Rober Galarga reviennent avec une nouvelle version dédié à la PS Vita. On retrouve ainsi énormément de fonctions qu'ont en commun les deux consoles. Il est de ce fait très facile de porter son jeu d'une console à l'autre !

On retrouve également des fonctions dédiés à l'installation des fameux ".VPK" et l'utilisation des polices au format ".TTF" en plus des ".PGF". Néanmoins, il faudra oublier les fonctions dédiées au son et à la 3D avec cette première version.

Les développeurs proposent également un outil nommé ONEMaker. Il permet de personnaliser son homebrew en changeant les métadonnées (nom et id de votre homebrew). Cependant, l'utilitaire est compatible uniquement avec Windows.

Vous trouverez d'ailleurs une documentation en anglais et en espagnol sur les fonctions disponibles. De plus, l'archive du ONELua R1 dispose de tout un tas d'exemples.

Avec cette version, les développeurs hispaniques proposent un Lua Player pour la compétition GekiHEN qui risque de faire parler de lui. En effet, beaucoup de homebrews risquent de l'utiliser, grâce aux diverses fonctions, mais également pour sa rétrocompatibilité avec son homologue PSP.

Si vous avez envie d'apprendre le Lua pour PSP et PS Vita, laissez un commentaire et je ferais peut être une série de tutoriels ! 

En attendant, bon développement ! ^^

L’article [GekiHEN] [Vita] Le ONELua maintenant compatible avec la PS Vita est apparu en premier sur Custom Protocol.

L'un des gros inconvénients était son incompatibilité avec l'émulateur de PSP pour PC et Android, PPSSPP, notamment au niveau des polices d'écritures. Voilà qui est corrigé si vous nommez votre police "oneFont.pgf" à la racine de votre homebrew, celle-ci sera utilisée alors par l'émulateur. N'oubliez pas de désactiver le Sofware Rendering et de cocher Fast Memory (unstable) dans les options de PPSSPP pour que votre homebrew se lance correctement ! ^^

Vous avez envie d'ajouter vos propres fonctions en C ? C'est possible grâce à la fonction os.requiere() via l'API (interface de programmation) incorporé au ONELua. Si vous aimez la syntaxe d'écriture du C, vous pouvez maintenant utiliser les opérations du langage comme la somme avec "+=" ou la soustraction "-=" par exemple.

Vous pouvez aussi dorénavant utiliser tous les boutons présents sur la PSP. Ainsi les boutons de volumes, Home/,  et  sont disponibles.

Comme si cela ne suffisait pas, vous pouvez maintenant utiliser les fonctionnalités infrarouges de votre PSP 1000 et si vous possédez une caméra, la Go! Cam ou celle de votre PS Vita, vous pouvez également utiliser des fonctions dédiés.

Si vous aimez dessiner des formes, vous allez être servi. Le ONELua peut maintenant dessiner des cercles, des triangles, des arcs... avec ou sans dégradé, remplis ou non, partiellement ou entièrement affichés.

De nombreuses autres nouveautés comme de nouveaux effets de splash screen, la possibilité de charger des images BMP, de récupérer de nouvelles données pour les autorisations de fichier ou récupérer la jaquette d'un MP3 par exemple sont au menu de cette version V4R1, ainsi que de nouveaux effets 3D et de nouvelles fonctions relatives au hardware. On peut noter également de nombreuses optimisations et corrections de bugs.

Peut on dire que le ONELua est le meilleur Lua Player sur PSP ? La réponse est oui car celui-ci propose un lot de fonctions conséquents tout en étant optimisé ! Le trio va continuer de développer le Lua Player mais sur d'autres plateformes comme sur PC. On attend cela avec impatience ! ;)

L’article [PSP] Le ONELua revient avec une mise à jour V4R1 est apparu en premier sur Custom Protocol.

Le développeur, qui a obtenu les soutiens de gdljjrod et de ZeroZelta (créateur de Fishell), a travaillé d'arrache-pied pendant 2 mois pour apprendre la programmation, coder le curseur, mettre un fond d'écran, ajouter des modules, etc. et arriver à ce résultat très convaincant. De nombreuses applications sont disponibles, et l'interface très intuitive se base sur le système d'exploitation Windows, bien connu de tous.

La navigation est très fluide mais la seule langue disponible pour l'instant semble être l'espagnol (langue de Davis et gdljjrod). Heureusement, les icônes et les ressemblances avec les mots français nous permettent de deviner (parfois) à quoi correspond telle ou telle chose.

Pour vous donner une petite idée, voilà la liste des applications que propose le shell :

• Explorateur de fichiers ;
• Terminal de commandes ;
• Visionneuse d'images ;
• Visionneuse d'objets 3D ;
• Lecteur de musiques (formats supportés : at3, mp3, wav, bgm) (Winamp) ;
• Éditeur photo (GIMP) ;
• Serveur FTP ;
• Éditeur de texte ;
• Anti-virus (non disponible pour le moment) ;
• Téléchargement de contenus (homebrews) (non-disponible pour le moment) ;
• Installateur interne d'applications ;
• Extraction/Lecture d'archives ;
• Google Maps (non-disponible pour le moment) ;
• Dumper d'UMD ;
• Chat Ad-Hoc (non-disponible pour le moment) ;
• Chat WLAN (non-disponible pour le moment) ;
• Exécuteur de homebrews, de backups (ISO/DAX) ou de jeux PS1 (PPSSPP) ;
• Gadgets :
  • Météo ;
  • Gestionnaire de RAM (mémoire vive) ;
  • Calendrier ;
  • Notes

Après de nombreux tests, un petit bug récurrent et agaçant à la longue a pu être observé : lorsque l'on quitte une application et qu'une autre se trouve dans la barre du bas, elle s'ouvre juste après sans avertir. Le clavier n'est également pas très agréable, mais l'est tout de même plus que le clavier de base de Sony.

Quoiqu'il en soit, il est bon de rappeler que le OneShell n'en est qu'à sa version bêta 0.3, et qu'il accomplit donc déjà beaucoup pour une version de test. Espérons que Davis ne lâchera pas la grappe et qu'il continuera d'améliorer son très prometteur projet !

L’article [PSP] L’impressionnant “OneShell” se met à jour est apparu en premier sur Custom Protocol.

En effet, c'est par un simple message sur Twitter que le développeur mexicain, gdljjrod, a annoncé la publication de la quatrième version du ONELua : au programme, encore de nouvelles fonctions mais aussi des corrections de bugs et une amélioration de la stabilité de l'interpréteur.

La première fonction qu'on voit au lancement d'un homebrew, splash.show() a été modifiée avec un effet de rebond sur l'image puis un éparpillement en morceau de celle ci. On dirait un vieux effet power point... ça plait ou pas car on ne peut pas remettre le simple effet d'apparition/disparition de l'image. Cependant on peut maintenant passer un splash en appuyant simplement avec la touche croix et le splash screen du ONELua a également changé.

splash.show()
----Affiche le splash du ONELua
----Ne retourne rien
splash.show("STRING")
----Affiche en splash le l'image sélectionnée
------STRING : Chemin où se trouve l'image 
----Ne retourne rien
splash.show({TABLE})
----Affiche les splashs des images sélectionnées un par un
------TABLE : Table contenant les chemins où se trouvent les images
----Ne retourne rien

On retrouve également plein de nouvelles fonctions pour pouvoir créer une connexion entre un ordinateur et la console (PSP/PSVita) en sans fil via le custom protocole FTP.

ftp.init()
----Initialise le module FTP
----Retourne TRUE si réussie sinon FALSE
ftp.term()
----Met fin le module FTP
----Retourne TRUE si réussie sinon FALSE
ftp.state()
----Retourne le statut du module FTP
----Retourne TRUE si actif sinon FALSE

Suite aux nouveautés du ONEMenu, l'interpréteur ONELua se voit doté officiellement de la lecture et l'affichage des fichiers .PMF, ces fichiers vidéos utilisés comme Gameboots de la PSP. On peut aussi lancer, stopper ou mettre en pause une vidéo en pleine exécution avec la fonction de callbacks onPmfPlay().

pmf.run("STRING")
----Lance le fichier PMF
------STRING : Chemin où se trouve le fichier PMF
----Ne retourne rien
pmf.run("STRING",NUMBER x,NUMBER y)
----Lance le fichier PMF
------STRING : Chemin où se trouve le fichier PMF
------POS x : Position X où afficher le fichier PMF
------POS y : Position y où afficher le fichier PMF
----Ne retourne rien
pmf.play()
----Met en position "Jouer" le fichier PMF
----Note : À utiliser avec la fonction callbacks onPmfPlay()
----Ne retourne rien
pmf.pause()
----Met en position "Pause" le fichier PMF
----Note : A utilisé avec la fonction callbacks onPmfPlay()
----Ne retourne rien
pmf.stop()
----Met en position "Stop" le fichier PMF
----Note : A utilisé avec la fonction callbacks onPmfPlay()
----Ne retourne rien

De nouvelles fonctions dans la catégorie maps font également leur apparition, en effet depuis la version 3 du ONELua il est possible de créer des maps avec un simple fichier texte et un fichier texture. Les deux développeurs ont ajouté 3 nouvelles fonctions qui seront bien pratiques pour les développeurs. Les deux premières permettent de retourner la largeur et la hauteur de la map générée, ce qui peut paraître intéressant pour gérer l'espace entre deux cartes de tailles différentes. La dernière permet quant à elle d'insérer une texture de l'image directement dans la map à une position donnée pour faire des animations par exemple.

map.sizex(MAP)
------MAP : variable contenant la map
----Retourne la largeur de la map
map.sizey(MAP)
------MAP : variable contenant la map
----Retourne la longueur de la map
map.set(MAP,NUMBER Tile_x,NUMBER Tile_y,NUMBER valeur)
----Permet d'insérer une texture dans la map
------MAP : variable contenant la map
------NUMBER Tile_x : la position x de la texture
------NUMBER Tile_y : la position y de la texture
------NUMBER Valeur : la texture à placer
----Ne retourne rien

D'autres fonctions ont été également ajoutées, comme celle permettant de convertir des couleurs en gris ou bien d'inverser la couleur sélectionnée.

color.fxinvert(COULEUR)
------COULEUR : variable contenant la couleur
----Retourne la couleur inversée
color.fxgray(COULEUR)
------COULEUR : variable contenant la couleur
----Retourne la couleur passée par le filtre gris

Ces fonctions se retrouvent aussi dans les nouvelles fonctions pour les images. On retrouve aussi avec celles-ci la possibilité d'appliquer un filtre sépia sur l'image choisie et de pouvoir récupérer une image avec un ancien effet appliqué.

image.fxinvert(IMAGE)
------COULEUR : variable contenant l'image
----Retourne l'image avec la couleur inversée
color.fxgray(IMAGE)
------IMAGE : variable contenant l'image
----Retourne l'image passée par le filtre gris
color.fxsepia(IMAGE)
------IMAGE : variable contenant l'image
----Retourne l'image avec un filtre sépia
color.fxold(IMAGE)
------IMAGE : variable contenant l'image
----Retourne l'image avec l'ancien effet
color.fxold(IMAGE,NOMBRE pourcent)
------IMAGE : variable contenant l'image
------NOMBRE : pourcentage de
----Retourne l'image avec l'ancien effet selon un certain pourcentage d'application

Pour finir, on retrouve des améliorations au niveau des performances mais également des corrections de bugs. Voilà, il est temps de vous fournir l'archive du ONELua V4 ainsi que la documentation complète en anglais (en .CHM ou en ligne) et de vous dire au revoir pour une prochaine news. 

L’article [PSP] [Vita] Une quatrième version pour le ONELua est apparu en premier sur Custom Protocol.

Cette version VFinal laisse suggérer qu'il s'agit de la dernière version du ONEMenu, en tout cas pour l'ARK-2. Suite à la mise en ligne du code source de l'ARK-3, fort est à parier que gdljjrod l'adaptera sans doute. En attendant, ONEMenu VFinal est la version la plus aboutie à ce jour et nous vous conseillons de l'adopter pour les raisons énumérées ci-dessous.

Quoi de neuf docteur ?

• Affichage des boots.pmf dans l'explorateur ;
• Possibilité de définir un fond d'écran depuis le lecteur d'images (l'image doit faire 480 x 270 pixels, l'application refuse d'ouvrir les images trop grandes) ;
• Possibilité de personnaliser à 100 % la couleur du menu (maintenir R dans l'option BarColor pour accéder au mélangeur) ;
• Correction de bugs divers.

Note : Screenshots pris depuis une PSP

Si ces quelques captures vous ont mis l'eau à la bouche, vous pouvez suivre notre tutoriel sur l'installation du ONEMenu (sur PS Vita) ! 

L’article [Vita] La mise à jour finale du ONEMenu débarque est apparu en premier sur Custom Protocol.

Après une première version qui nous avait plutôt convaincue mais dotée d'un seul niveau, cette deuxième version réussira-t-elle à combler le manque de niveaux ?

Tout d'abord, au lancement du jeu, on peut maintenant si on le souhaite et si on possède un câble adapté, retransmettre le jeu sur notre télévision (grâce aux nouvelles fonctionnalités du ONELua). Le jeu se lance avec plusieurs animations et temps de chargement avant que le joueur parvienne enfin au menu principal en ayant le choix entre lancer une partie, sélectionner la musique, accéder aux réglages du homebrew et pour finir quitter Space Ball. Deux modes de jeu sont par ailleurs disponibles : "arcade", où les 3 niveaux se suivent, ou bien "niveau simple", où l'on peut sélectionner le level de son choix.

Attention cependant : vous ne possédez que 9 tirs par niveau, si vous échouez vous retournerez au menu du jeu. Pas de possibilité de recommencer un niveau sans perdre la progression, donc. C'est frustrant sachant que les deux derniers niveaux sont très très difficiles car il y a des zones infranchissables emplis d'une sorte de masse gluante ou encore des tapis roulants.

Le sélecteur de niveau permet de sélectionner l'un des trois niveaux mais comme avec le mode arcade, si on perd en ne réussissant pas à mettre la balle dans le trou après les 9 coups, on retourne au menu avec un temps de chargement qui devient assez énervant.

Parlons maintenant du jeu en lui même : c'est beau, il y a des reflets, des ombres... bref on pourrait croire à un jeu développé par un studio indé de jeux vidéo. Et on si croirait même si on ne comprend pas le fait qu'il y ait un golf dans l'espace, mais passons ce détail.

Le menu des musiques permet quant à lui de proposer à l'écoute les 3 superbes musiques du jeu, dommage qu'il n'en est pas d'avantage même si les trois sont de très bonne facture.

Dans les options du homebrew, on retrouve la possibilité de régler la vitesse du processeur pour une plus grande rapidité (soit 222 ou 333 Mhz) et d'activiter l'option pour la retransmission sur la télévision. On peut accéder également à partir de ce menu aux Infos permettant d'accéder à l'aide pour les contrôles et les crédits du jeu.

Pour conclure, cette nouvelle version apporte son lot de nouveautés même si on regrette le nombre toujours limité de niveau, l'obligation de recommencer depuis le début en mode arcade et les temps de chargements. Cependant, Space Ball reste un bon exemple de la puissance de la PSP et sa capacité à afficher de la 3D, en plus de montrer les merveilles du Lua.

Note : Mills devrait, dans un futur proche, proposer une version Android de son homebrew. Nous attendons cela avec impatience !

L’article [PSP] Space Ball : la version 2 est sortie 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.

Comme vous pouvez vous en douter, c'est le catalogue du One Installer qui a tout d'abord été agrandi en fournissant à l'utilisateur toujours plus de jeux, émulateurs, utilitaires, plugins, thème, etc. Mais l'ajout notable est la traduction de l'application en français (merci @Applelo1) et l'amélioration considérable du design !

De nouvelles options sont aussi désormais offertes à l'utilisateur, comme la possibilité d'afficher les captures d'écran via la touche "Carré" ou de se déplacer dans un explorateur de fichiers. Et la prise en main est tellement simple qu'il est inutile de vous détailler comment vous en servir (on met quand même les commandes en bas évidemment). ;) Vous pouvez même lâcher un petit commentaire sur la page d'un programme et l'évaluer.

Laissons plutôt place aux screenshots (pris par @Applelo1), car comme le disait notre bon vieux Napoléon, une image vaut bien mille discours :

Commandes

• Menu principal
  • Pad digital : faire défiler
  • Triangle : ouvrir le menu du One Installer (2R0)
  • Rond : retour/annuler
  • Croix : valider/entrer
• Téléchargement
  • Gâchettes L & R : basculer sur le contenu précédent/suivant
  • SELECT : (2R0)
  • Carré : afficher les captures d'écran (2R0)
  • Rond : retour/annuler
  • Croix : valider/entrer
• Explorateur de fichiers (2R0)
  • Haut/Bas : déplacer le curseur
  • Gâchettes L & R : se déplacer plus rapidement vers le haut/bas
  • Triangle : ouvrir/fermer le menu des fonctions
  • Rond : précédent/annuler
  • Croix : ouvrir/valider
  • SELECT : fermer navigateur de fichiers
• Commentaires
  • Pad digital : faire défiler les commentaires
  • Rond : quitter
• Écriture d'un message
  • Pad digital : se déplacer sur le clavier
  • Touches d'action (Croix/Carré/Triangle/Rond) : entrer le caractère correspondant à la position de la touche sur la console
  • SELECT : basculer entre l'écriture du titre/message
  • START : envoyer le commentaire
• À propos
  • Rond : quitter.

Changelog

• Compilation du homebrew en "ISO" ;
• Amélioration considérable de l'interface graphique
• Automatisation de l'intallation des futures mises à jour du One Installer
• Ajout de la langue français (by @Applelo1)
• Possibilité d'évaluer un contenu
• Affichage d'un top 3 sur le menu principal
• Support de l'affichage de captures d'écran
• Ajout d'un explorateur de fichiers :
  • Possibilité d'effectuer les actions de base, à savoir copier/coller/déplacer/supprimer
  • Possibilité d'extraire des archives RAR ou ZIP
  • Possibilité de créer des dossiers
  • Possibilité de renommer des fichiers et dossiers
  • Possibilité d'afficher les images PNG et JPG
  • Possibilité d'exécuter des ISO, jeux PS1 ainsi que des homebrews
• Ajout d'un petit menu :
  • Possibilité de connecter sa PSP à son ordinateur via USB
  • Possibilité d'éteindre la PSP
  • Possibilité de sortir du logiciel

Le gestionnaire de plugin et le formulaire de contact ne sont pas encore disponibles dans cette révision. En tout cas, on ne peut que souhaiter à Davis de continuer son très beau projet ! 

L’article [PSP] One Installer passe en version 2R0 est apparu en premier sur Custom Protocol.

En effet, gdljjrod et Robert Galarga, les deux créateurs du OneLua, ont décidé de revenir à la charge et ont posté deux nouveautés qui nous mettent l'eau à la bouche.

La première principale nouveauté devrait ravir tout ceux qui réalisent des jeux utilisant des graphismes 2D et qui ont besoin de performance. C'est ainsi via un simple fichier texte et une image contenant les textures du jeux, généré à partir du logiciel GBA Graphics 0.19 sur votre ordinateur, que vous pourrez créer le début d'un jeu de plateformes ou bien de rôle. 

map.new(img_tileset, table_map, number_tilex, number_tiley)--Charge la map
map.blit(map, number_x, number_y)--Affiche la map

La deuxième nouveauté nommée os.modetv va permettre d'activer la retransmission de votre écran à votre télé via un adaptateur, de plus la fonction permet de régler la qualité de la retransmission.

os.tvmode(number_quality)--Active le TVMode
_0000 (32 Bits RGBA)
_4444 (16 Bits R4G4B4A4)
_5551 (16 Bits R5G5B5A1)
_5650 (16 Bits R5G5B5 sans chaîne alpha)
os.tvmode()--Désactive le TVMode

Bref, de belles nouveautés en somme, espérons que d'autres surprises arrivent d'ici peu ainsi que cette troisième version du OneLua qui reste le Lua Player sur PSP le plus abouti à ce jour comme le prouve la vidéo ci-dessous !

L’article [PSP] [Vita] La version 3 du OneLua arrive très bientôt est apparu en premier sur Custom Protocol.