@DATABASE Hollywood.guide @AUTHOR "Andreas Falkenhahn" @$VER: Hollywood.guide 4.0 (26.02.2009) @INDEX V6Reference @HELP V6Reference @NODE Main "Hollywood : Tables des matières" -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- -= @{B}@{FG highlight}H O L L Y W O O D@{FG text}@{UB} =- The Cross-Platform Multimedia Application Layer -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- @{APEN 16}@{b}I. Introduction@{ub}@{APEN 1} @{" 1 Introduction " LINK Introduction} Que fait-on avec Hollywood? @{" 1.1 Copyright & Disclaimer " LINK Copyright} Pas de garantie collatérale @{" 1.2 Eléments requis " LINK Requirements} De quoi avez-vous besoin pour que ça fonctionne @{" 1.3 Publier vos scripts " LINK ImportantInformation} Lisez ceci @{" 2 Le Package Hollywood " LINK Package} Présentation de l'installation d'Hollywood @{"2.1 Utilisation via la console " LINK ManualUsage} Les arguments de la console et les tooltypes @{"2.2 Utilisation via l'interface graphique " LINK GUI} Information de base sur l'interface graphique @{"2.3 Utilisation du compileur & du lieur " LINK Compiler} Compiler vos scripts @{"2.4 Utilisation de l'enregistreur vidéo " LINK VideoRecorder} Sauvegarder vos script en fichier vidéo AVI @{"2.5 Moteur de redimensionnement automatique " LINK AutoScalingInfo} Pour une flexibilité maximale @{"2.6 Les applets Hollywood " LINK Applets} Information sur les applets Hollywood @{"2.7 Changement dans l'interface de programmation " LINK APIChanges} Liste des changements sur l'interface de programmation @{" 3 A propos d'Hollywood " LINK Philosophy} La philosophie derrière le programme @{"3.1 Histoire " LINK History} Que s'est-il passé avant @{"3.2 Future " LINK ToDo} Quelle innovation dans le future @{"3.3 F.A.Q. " LINK FAQ} Foire aux questions @{"3.4 Remerciements " LINK Credits} Qui a été impliqué dans le projet @{"3.5 Mailing list et forum " LINK MailingList} Demandez ici si vous avez besoin d'aide @{"3.6 Contacter Moi " LINK Contact} Comment correspondre avec moi @{APEN 16}@{b}II. Le langage @{ub}@{APEN 1} @{" 4 Mise en route " LINK V6PrgIntroduction} Votre premier programme avec Hollywood @{"4.1 Identifiants réservés " LINK V6PrgIdentifiers} Les identifiants réservés du langage @{"4.2 Les commandes préprocesseur " LINK V6PrgPreproc} Utilisées les pour précharger des images, sons et bien plus @{"4.3 Conversion des chaînes et des nombres " LINK V6PrgStrNumConv} Hollywood peut convertir automatiquement Nombres/chaînes @{"4.4 Commentaires " LINK V6PrgComments} Les bons programmeurs commentent leurs scripts @{"4.5 Includes " LINK V6PrgIncludes} Découper vos projets en plusieurs fichiers @{"4.6 Suggestions d'écriture de scripts " LINK V6PrgStyleguideSuggestions} Rendez vos scripts lisibles @{" 5 Types de données " LINK V6PrgTypeIntro} Brève présentation des types de données @{"5.1 Nombres " LINK V6PrgTypeNumber} Entier ou à virgule @{"5.2 Chaînes " LINK V6PrgTypeString} Séquences de caractères @{"5.3 Tableaux " LINK V6PrgTypeTable} Espace de stockage pour plusieurs données @{"5.4 Fonctions " LINK V6PrgTypeFunc} Sous-routines appelées par l'utilisateur @{"5.5 Nil " LINK V6PrgTypeNil} Type spécial d'une variable non initialisable @{" 6 Expressions et opérateurs " LINK V6PrgOpr} Qu'est-ce qu'une expression? Qu'est-ce qu'un opérateur? @{"6.1 Opérateurs Arithmétiques " LINK V6PrgOprArith} opérateurs mathématiques de base @{"6.2 Opérateurs Relationnels " LINK V6PrgOprRelat} Vérifier la relations entre 2 opérandes @{"6.3 Opérateurs Logiques " LINK V6PrgOprLogic} Opérateurs And, Or et Not @{"6.4 Opérateurs Binaires " LINK V6PrgOprBitw} Déplacer les bits et effectuer des opérations binaire @{"6.5 Concaténation de chaînes " LINK V6PrgOprStrng} Concaténé plusieurs chaînes en une seule @{"6.6 Priorités des opérateurs " LINK V6PrgOprPri} Tous les opérateurs Hollywood et leurs priorités @{" 7 Variables et constantes " LINK V6PrgVariables} Introduction aux variables et aux constantes @{"7.1 Variables Globales " LINK V6PrgGlobals} Variables qui sont globalement disponibles @{"7.2 Variables Locales " LINK V6PrgLocals} Variables qui sont limitées dans le temps @{"7.3 Collecteur de données perdus " LINK V6PrgGarbageCollector} Hollywood exécute ceci de temps en temps @{"7.4 Constantes " LINK V6PrgConstants} Comment déclarer des constantes @{"7.5 Constantes interne " LINK V6PrgInbuiltCst} Constantes internes spéciales @{"7.6 Constantes de caractères " LINK V6PrgCharacterCst} Comment utiliser les constantes de caractères @{" 8 Contrôle de flux de programme " LINK V6PrgFlow} Déclaration qui contrôle le flux du programme @{"8.1 Déclaration If-EndIf " LINK V6PrgIf} Bloc conditionnel @{"8.2 Déclaration While-Wend " LINK V6PrgWhile} Boucle jusqu'à se qu'une condition soit TRUE @{"8.3 Déclaration For-Next " LINK V6PrgFor} Boucle autant de fois que le nombre spécifié @{"8.4 Déclaration Repeat-Until " LINK V6PrgRepeat} Boucle jusqu'à se qu'une condition devienne TRUE @{"8.5 Déclaration Switch-Case " LINK V6PrgSwitch} Simple bloc conditionnel @{"8.6 Déclaration Break " LINK V6PrgBreak} Stopper la boucle ou basculer @{"8.7 Déclaration Continue " LINK V6PrgContinue} Continuer la boucle @{"8.8 Déclaration Return " LINK V6PrgReturn} Retour d'une fonction à un appel @{"8.9 Déclaration Block-EndBlock " LINK V6PrgBlock} Créer un nouveau bloc @{" 9 Fonctions " LINK V6PrgFunctions} Introduction aux fonctions @{"9.1 Les fonctions sont des variables " LINK V6PrgFuncVar} Toutes fonctions est une variable normale @{"9.2 Fonction de retour " LINK V6PrgFuncCallback} Apprendre à travailler avec les fonctions de retour @{"9.3 Valeurs de retour " LINK V6PrgFuncRetVals} Information avancée sur les valeurs de retours @{"9.4 Fonction récursive " LINK V6PrgFuncRec} Hollywood supporte complètement la récursivité @{"9.5 Les variables nombre en argument " LINK V6PrgFuncVarArgs} Comment déclarer une variable nombre en argument @{"9.6 Fonction comme membre de tableau " LINK V6PrgFuncTable} Les fonctions peuvent être stockées dans des tableaux @{"9.7 Fonction Locales " LINK V6PrgFuncLoc} Les fonctions peuvent être également Locale @{" 10 Bon à savoir " LINK V6PrgG2KIntro} Quelques informations sur Hollywood @{"10.1 Mécanisme de synchronisation de script " LINK V6PrgG2KTiming} Un paragraphe très important. Lisez ceci @{"10.2 Techniques d'animations " LINK V6PrgG2KAnimation} Trouver la meilleur technique d'animation pour vos projets @{"10.3 Le masque et le canal alpha " LINK V6PrgG2KMaskAlpha} Quelle est la différence entre les deux? @{"10.4 Dépannage " LINK V6PrgG2KTroubleshooting} Parfois il y a des erreurs @{"10.5 Tutorial " LINK V6PrgG2KTutorial} Votre slideshow Hollywood en 10 étapes @{APEN 16}@{b}III. Référence des commandes@{ub}@{APEN 1} @{" 11 Bibliothèque d'événement " LINK V6LibEvent} Introduction à la Bibliothèque d'événement @{"11.1 Fonctions boutons " LINK V6LibEventButton} Créer des boutons et déclarer les événements @{"11.2 Les événement déclare des fonctions " LINK V6LibEventHandler} Documentation de la commande WaitEvent() et bien plus @{"11.3 Fonction d'intervalle " LINK V6LibEventInterval} Comment installer une fonction d'intervalle @{"11.4 Fonction Timeout " LINK V6LibEventTimeout} Installer une fonction timeout @{"11.5 Fonction interaction avec l'utilisateur " LINK V6LibEventInput} Fonction sur l'interaction avec l'utilisateur @{"11.6 Fonction ARexx " LINK V6LibEventARexx} Communiquer avec d'autres programmes @{"11.7 Fonction de compatibilité " LINK V6LibEventCompat} Fonction Hollywood 1.x compatible @{" 12 Bibliothèque mathématique " LINK V6LibMath} Le grand laboratoire mathématique d'Hollywood @{" 13 Bibliothèque chaîne " LINK V6LibString} Fonction pour manipuler des chaînes @{" 14 Bibliothèque graphique " LINK V6LibGfx} Introduction à la Bibliothèque graphique d'Hollywood @{"14.1 Graphique primitifs " LINK V6LibGfxDraw} Rectangles, lignes, cercles, polygones @{"14.2 Fonction image de fond " LINK V6LibGfxBGPic} Tous sur les images de fond d'écran @{"14.3 Fonction d'affichage " LINK V6LibGfxDisplay} Fonction pour manager votre écran @{"14.4 Fonction brosse (Brush) " LINK V6LibGfxBrush} Afficher et contrôler vos brosse (brush) @{"14.5 Fonction Animation " LINK V6LibGfxAnim} Fonction lecture d'animation @{"14.6 Fonction Calque (layer) " LINK V6LibGfxLayer} Fonction de mangement de calques (layers) @{"14.7 Fonction Sprite " LINK V6LibGfxSprite} Tous sur les sprites @{"14.8 Fonction Double buffer " LINK V6LibGfxDoublebuffer} affichage avec Double-buffer sous Hollywood @{"14.9 Fonction diverses " LINK V6LibGfxMisc} Détection de collision et autres fonctions @{" 15 Bibliothèque texte " LINK V6LibText} Introduction à la Bibliothèque Texte d'Hollywood @{"15.1 Fonction police de caractère " LINK V6LibTextFont} Charger des polices, paramétrer les styles de polices @{"15.2 Fonction affichage du texte " LINK V6LibTextRender} Fonction affichage de textes @{"15.3 Fonction objet texte " LINK V6LibTextObject} Comment créer un objet texte @{" 16 Bibliothèque sonore " LINK V6LibSound} Introduction à la Bibliothèque sound d'Hollywood @{"16.1 Fonction échantillon sonore " LINK V6LibSoundSample} Fonction lecture d'échantillons sonore @{"16.2 Fonction musique " LINK V6LibSoundMusic} Fonction pour lire des mp3 et des modules Protracker @{"16.3 Fonction diverses " LINK V6LibSoundMisc} D'autres fonctions relatives au son @{" 17 Bibliothèque Dos " LINK V6LibDOSFunctions} Fonction pour les E/S de fichier et bien plus @{" 18 Bibliothèque système " LINK V6LibSys} Introduction à la Bibliothèque système d'Hollywood @{"18.1 Fonction date et heure " LINK V6LibSysDate} Interroger la date système, le jour et bien plus @{"18.2 Fonction mesure du temps " LINK V6LibSysTimer} Mesurer le temps entre 2 temps @{"18.3 Fonction Local " LINK V6LibSysLocale} Support de différents langage s @{"18.4 Fonction de requêtes " LINK V6LibSysReq} Afficher plusieurs types de requête @{"18.5 Fonction de débugage " LINK V6LibSysDebug} Fonction de bas niveau pour le débugage @{"18.6 Fonction liste " LINK V6LibSysList} Les tableaux peuvent être utilisés comme une liste @{"18.7 Fonction pointeur de souris " LINK V6LibSysPointer} Installer un nouveau pointeur de souris @{"18.8 Fonction bloc mémoire " LINK V6LibSysMemory} Fonction de bas niveau pour les blocs mémoires @{"18.9 Fonctions diverses " LINK V6LibSysMisc} D'autres fonctions systèmes @{" 19 Index Hollywood trié par ordre alphabétique " LINK V6Reference} Trouver rapidement les commandes que vous rechercher -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- @{APEN 16}Hollywood (C) Copyright © 2002-2009 Andreas Falkenhahn Tous droits réservés@{APEN 1} -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- @ENDNODE @NODE Copyright "Guide Hollywood" @{APEN 4}@{b}DROITS A LA COPIE@{ub}@{APEN 1} Hollywood(c) est protégé par les droits de publication 2002-2009 par Andreas Falkenhahn. Le programme est fourni "tel quel" et l'auteur ne peut pas être rendu responsable de tout tort possible fait par le logiciel. L'utilisation commerciale des applications créés avec Hollywood sont seulement permises avec une autorisation écrite de l'auteur. Aucune modification ne peut être apportée aux programmes sans autorisation de l'auteur. il est interdit de diffuser ce programme sans autorisation écrite de l'auteur. Ce logiciel est basé en partie sur le travail du groupe indépendant JPEG Group. Ce logiciel est basé en partie sur la bibliothèque libpng par PNG. Le groupe de développement et la bibliothèque zlib par Jean-loup Gailly et Mark Adler. Ce logiciel est basé en partie sur les droits de publication 2001, 2003, 2004 de PTPlay (c) par Ronald Hof, Timm S. Mueller, Per Johansson. Amiga est une marque déposée de Amiga Inc. Toutes autres marques déposées appartiennent à leurs propriétaires respectifs. @{b}Hollywood 4.0 Responsabilité@{ub} ============================ @{APEN 4} IL N' Y A AUCUNE GARANTIE POUR LE PROGRAMME, DANS LES LIMITES AUTORISEES PAR LA LOI APPLICABLE. SAUF INDICATION CONTRAIRE ECRITE, LES DROITS D'AUTEUR, LE SUPPORT ET/OU D'AUTRES PARTIES METTENT LE PROGRAMME "TEL QUEL" SANS AUCUNE GARANTIE DE TOUTES SORTES, SOIT EXPLICITE OU IMPLICITE, Y COMPRIS, MAIS SANS S'Y LIMITE, LES GARANTIES IMPLICITES DE LA VALEUR MARCHANDE ET D'ADAPTATION POUR UN BUT PARTICULIER. TOUT LES RISQUE QUANT à la QUALITE ET LA PERFORMANCE DU PROGRAMME EST VOTRE. SI LE PROGRAMME EST DEFECTUEUX, VOUS DEVEZ ASSUMER LES COUTS DE TOUT ENTRETIEN, DEPANNAGE OU CORRECTION. EN AUCUN CAS SAUF LORSQUE LA LOI APPLICABLE OU UNE CONVENTION ECRITE DETENU PAR N'IMPORTE QUEL DETENTEUR DU COPYRIGHT, OU N'IMPORTE QUELLE AUTRE PARTIE PEUT REDISTRIBUER LE PROGRAMME COMME AUTORISE CI-DESSUS, NE POURRA ETRE TENU RESPONSABLE ENVERS VOUS POUR DOMMAGES, Y COMPRIS LES DEGATS : GENERAUX, SPECIAUX, FORTUITS OU CONSECUTIFS PROVENANT DE UTILISATION OU INCAPACITE D'UTILISER LE PROGRAMME (Y COMPRIS MAIS NON LIMITE à la PERTE DE DONNEES OU LES DONNEES RENDUES INEXACTE OU LES PERTES SUBIES PAR VOUS OU TIERS OU UNE DEFAILLANCE DU PROGRAMME A FONCTIONNER AVEC TOUT AUTRE PROGRAMMES), MEME SI LE DIT TITULAIRE OU TOUTE AUTRE PARTIE A ETE INFORME DE LA POSSIBILITEE DE TELS DOMMAGES. @{APEN 1} Le langage qui est utilisé pour programmer Hollywood est basé sur le noyau du langage léger et libre de programmation Lua de Roberto Ierusalimschy, Waldemar Celes et Luiz Henrique de Figueiredo. Hollywood utilise de façon significative un noyau modifié de Lua 5.0.2. ================================================================================== + Licence de Lua 5.0 + + Copyright © 1994-2004 Tecgraf, PUC-Rio. + + la permission est par la présente accordée, gratuitement, à toute personne + + obtenant une copie de ces logiciel et des fichiers de documentation (le + + "logiciel"), d'utiliser le logiciel sans restriction, y compris sans la + + limitation du droit d'utilisation, copier, modifier, fusionner, publier, et + + concéder sous licence, et/ou vendre des copies du logiciel, et à autoriser les + + personnes auxquelles le logiciel est fourni à en faire autant, sous + + réserve des conditions suivantes : + + + + l'avis de copyright ci-dessus et la présente autorisation doivent être inclus + + dans toutes les copies ou parties substantielles du logiciel. + ================================================================================== Les parties d'Hollywood qui utilisent la bibliothèque OpenCV d'Intel Corporation: ================================================================================== + contrat de licence d'Intel pour la bibliothèque Open source Computer Vision + + Copyright © 2000, Intel Corporation, tous droits réservés. Les droits de copie + + des parties tiers sont la propriété de leurs propriétaires respectifs. + + La redistribution et l'utilisation sous forme des sources et binaires, avec ou + + sans modification, sont autorisées à condition que les conditions suivantes + + soient remplies : + + - la redistribution des codes sources doit comprendre la notice de copyright + + ci-dessus, cette liste de conditions et de renonciation suivante. + + - la redistribution en forme binaire doit comprendre la notice de copyright + + ci-dessus, cette liste de conditions et de renonciation suivante dans la + + documentation et/ou autres documents fournis avec la distribution. + + - le nom d'Intel Corporation ne peut être utilisé pour cautionner ou + + promouvoir des produits dérivés de ce logiciel sans autorisation écrite + + préalable. + + ce logiciel est fourni par les détenteurs du copyright et les contributeurs + + "tel quel" et toutes garanties expresse ou implicite, y compris, mais sans + + s'y limiter, les garanties implicites de valeur marchande et de l'adéquation à + + un usage particulier est désavouée. En aucun cas, Intel ou les contributeurs + + ne seront tenue responsable des dommages directs, indirects, fortuits, ou + + spéciaux, exemplaires, ou consécutifs (y compris, mais sans s'y limiter, les + + achats de biens ou de substitution; perte d'utilisation, de données ou profits + + et interruption d'exploitation) qu'elle qu'en soit la cause et sur toute + + théorie de la responsabilité, qu'elle soit contractuelle, la responsabilité + + sans faute intentionnelle, ou d'acte délictuel (négligence y compris ou autre) + + découlant de quelque manière de l'utilisation de ce logiciel, même s'il a été + + avisé de la possibilité de tels dommages. + ================================================================================== @ENDNODE @NODE Introduction "Guide Hollywood" @{APEN 16}@{b}Introduction@{ub} @{APEN 1} Hollywood est une application de calques multimédia multi-platforme. Cela signifie qu'il offre un puissant langage de script 64-bit, assorti de fonctions avancées qui vous permettent de créer vos propres applications multimédias, allant d'une simple présentation à un jeu complexe. Hollywood est distribué sur un CD-ROM qui contient une version d'AmigaOS 3 (68k), de WarpOS (PowerPC), de MorphOS (PowerPC) et d'AmigaOS 4 (PowerPC), et également une version AROS (i386). L'énorme avantage d'Hollywood, c'est son compilateur multi-systèmes. Vous ne devez pas vous inquiéter, si par exemple, votre application doit fonctionner sur 68k, PowerPC ou i386. Avec Hollywood elle fonctionne sur tous les systèmes. Même pour les opérations les plus complexes, Hollywood a des fonctions simples qui les créeront pour vous, ainsi vous pouvez vous concentrer sur l'élément important, votre application. Le puissant moteur d'Hollywood vous permet de créer des présentations qui peuvent être parfaitement synchronisées avec la musique, peu importe si votre présentation s'exécute sur un CPU de 50 ou 1 gigahertz. Hollywood est entièrement en 32 bits amélioré ce qui signifie que vous pouvez utiliser des images allant jusqu'à 16.7 millions de couleurs et un canal alpha. De plus, il est pleinement intégré dans l'AmigaOS(TM) et ne s'appuie pas sur un composant matériel spécifique. Par conséquent, Hollywood fonctionne également sur des émulateurs comme Amithlon ou WinUAE avec une vitesse étonnante. Hollywood est livré avec une interface graphique qui permet de contrôler le programme de façon efficace et simple. En utilisant le langage de script Hollywood, les possibilités sont presque infinies. La version de base d'Hollywood est livrée avec plus de 380 commandes qui vont des commandes de disque du système d'exploitation (DOS) à des commandes qui vous permettent de déplacer facilement des animations et des graphismes sur votre écran. Il existe également de nombreuses commandes qui vous permettent d'afficher des objets, des images et des textes avec plus de 150 effets de transition sympathique ou le redimensionnement graphiques et d'animations. Vous pouvez également utiliser un effacement doux d'objets de 24 bits , de textes et d'images. Avec le nouveau calque Hollywood, impossible n'est pas français : Vous avez le contrôle total sur la position, les réglages de transparence et de lumière de chaque calque qui vous permet de réaliser presque tout. Hollywood utilise le système des datatypes pour charger les images, animations et les sons que vous utilisez sous tous les formats dont vous avez les datatypes. De plus, il supporte des choses uniques comme les fenêtres transparentes qui améliore considérablement le look-and-feel de votre écran Workbench. Vous pouvez utiliser les polices true type, intellifonts,les polices bitmap standard, et même les couleurs de police Amiga avec Hollywood. Naturellement, l'antialiasing est entièrement pris en charge pour toutes les polices vectorielles. Hollywood a un processeur d'image intégré qui offre de nombreuses possibilités pour manipuler des graphismes de manière simple et efficace. Vous pouvez appliquer les opérations suivantes aux images : Rotation, redimensionner, étirer, éclaircir, assombrir, miroir, échelle de niveau de gris, la texture, inverser, teinter, remplacer des couleurs et mélanger des images. Grâce à ses nombreuses opérations, Hollywood vous soutient avec tout les outils pour le traitement d'images moderne. Depuis Hollywood 2.0, le programme est fourni avec une bibliothèque étendue de sprite qui est indispensable pour tous les développeurs de jeux. Les sprites Hollywood sont complètement implémentés dans le logiciel et sont donc pas limités en taille ou la profondeurs de couleurs : Vous pouvez utiliser des sprites énormes avec 16.7 millions de couleurs et un canal alpha. La bibliothèque de sprite comporte également des options comme la détection de collision au pixel près. Le système de son intégré est entièrement redirigeable via AHI et vous permet de jouer des modules de musique, des échantillons sonores, et des MP3. Le système de son inclus comporte le mixage de tous les canaux et de l'effet du volume principal. Vous pouvez jouer pratiquement un nombre illimité de sons de toute longueur en même temps. En 16 bits et 44.1 KHz évidement. Les caractéristiques Hollywood sont complétées par le support d'ARexx. Vous pouvez communiquer avec d'autres applications par l'intermédiaire d'ARexx et vous pouvez également ouvrir vos propres port ARexx et recevoir des commandes par son intermédiaire. Ceci vous permet d'optimiser davantage vos script et de créer des applications qui peuvent également être contrôlées par l'intermédiaire d'ARexx. Tout ceci peut être effectué très facilement avec juste quelques lignes de code. Rappelez-vous que Hollywood fournit toujours une flexibilité maximale avec un minimum de travail. Hollywood est une application haut de gamme qui a besoin d'une configuration moderne d'Amiga pour fonctionner. Puisque, un mode d'écran en Hi- ou Truecolor est nécessaire pour Hollywood et vous devez avoir au moins 16 méga-octets de mémoire libre après un boot. Hollywood est absolument le choix numéro un dans la création multimédia pour Amiga (TM) de nos jours et porte l'Amiga de nouveau à ses racines... le Multimédia. Il est livré avec un compilateur qui peut sauvegarder vos applications en tant qu'exécutables autonomes Amiga qui fonctionnent sans bibliothèques externes. De plus chaque version d'Hollywood peut sauvegarder les exécutables pour chaque plate-forme compatible Hollywood. Ainsi vous pouvez utiliser votre version 68K Hollywood pour créer des exécutables AmigaOS4 et vice versa. Ceci vous permet de distribuer des versions AmigaOS4 de vos projets sans les créer sous AmigaOS4. Un autre exemple: Les utilisateurs de MorphOS peuvent créer des versions 68k, OS4, WarpOS, ou même AROS. Depuis Hollywood 3.0 il est même possible de compiler des programmes pour Microsoft Windows et MacOS. Hollywood est livré sur un CD-ROM avec plus de 50 exemples prêts à fonctionner, cela permet de se rendre compte de la puissance du logiciel. Il y a presque 1 méga-octet de documentation qui explique chaque champ d'application d'Hollywood. Bien que tout ceci semble un peu compliqué, il est très facile d'utilisation. Des compétences en programmation ne sont pas nécessaires. Elles sont utiles seulement si vous voulez créer des applications complexes mais pour l'usage courant d'Hollywood vous n'en n'aurez pas besoin puisque Hollywood est vraiment facile à manipuler. @{APEN 16}@{b}Caractéristiques :@{ub} Graphiques : @{APEN 1} - Entièrement optimisé en 32 bits - Bibliothèque puissante de sprite - Support des graphismes alpha-blended - Support de multiple calques graphiques (Layers) - Support de calque transparent et de correction de lumière - Les fenêtres transparentes sont possibles - Plus de 150 effets de transitions pour les objets , les images et les textes - De nombreuses transitions comme des ondulations aquatiques, strudel, tempête de pixel etc... - Des graphismes peuvent être déplacés en douceur - Un processeur d'image intégré qui prend en charge : La Rotation, inversion de couleur, mise à l'échelle de gris, axe de retournement, texturation, mélange et teinture - Lecture lisse et fluide d'animations - Support pour les graphismes et les animations transparentes dont la transparence alpha - Fonctions pour l'utilisation de textures et la création de dégradés - Support des datatypes - Animation facile des objets - Soutien aux polices de caractères true type, Intelli, bitmap et les polices de couleur, y compris la prise en charge de l'antialiasing - Puissant moteur de texte avec une mise en forme en temps réel comme le HTML - La mise à l'échelle et la rotation libre d'images sont possibles - Le rendu hors-écran est pris en charge (également pour les masques et les canaux alphas) - Intégration Faciles du système UNDO - Vaste bibliothèque graphique qui peut réaliser des ellipses, des lignes, des rectangles, des polygones, des rectangles arrondis, etc... - Support complet pour les graphismes anti-aliased - Style intégré pour ajouter une ombre et une bordure sur du texte et des graphismes - Les régions clip peuvent être installées (de forme rectangulaire ou personnalisé) - détection de collision au pixel près (le masque et le canal alpha sont pris en charge également!) - fonctions faciles à installer pour un écran double buffer - Soutien à l'exportation y compris l'exportation d'images PNG avec canal alpha @{APEN 16} Son : @{APEN 1} - Support des MP3 et des échantillons - La lecture en streaming audio est possible - Mixage de tous les canaux - Support des modules de musique - Le volume et la fréquence d'échantillons peuvent être modifiées en cours de lecture - Les tailles d'échantillons ne sont pas limitées - Lecture stéréo en 8 ou 16 bits - Effet volume principal - Entièrement paramétrable via AHI @{APEN 16} Langage de script : @{APEN 1} - Langage de script 64-bits puissant, rapide, et extrêmement souple - Très facile à utiliser. Conversion automatique entre les chaînes et les nombres. - Les scripts s'exécutent dans un sandbox: Ils ne peuvent pas planter votre système. - Beaucoup de types de données différentes: chaînes, nombres, constantes, tableaux, documents, structures - Prise en charge de tous les éléments de langage courant (If, While, For, Repeat, Switch, Function, Goto, Gosub) - Manipulation facile des variables (initialisation et déclaration non nécessaires) - Variables locales et globales - Le langage a des opérateurs pour l'addition, la soustraction, la multiplication, la division, la division de nombre entier, la concaténation de chaîne, le modulo, les exposants, And logique, Or logique, Not (logique et au niveau du bit), déplacement vers la gauche, déplacement vers la droite, xor binaire - Le langage peut même être utilisé pour la programmation orientée objet - Compilateur et relieur de liens pour convertir votre script en un fichier exécutable - Le compilateur peut créer des fichiers exécutables: OS3, MorphOS, WarpOS, AmigaOS4, AROS, Windows, et Mac OS - Gestionnaire d'erreurs intégré qui effectue tout le travail de gestion d'erreurs - Fonctions pour déboguer votre script - Communiquer avec d'autres applications Hollywood via ARexx - Prise en charge pour l'installation de ports ARexx propres dans le système - Des plugins peuvent être utilisés pour améliorer les fonctionnalités d'Hollywood @{APEN 16} Interaction utilisateur : @{APEN 1} - Des boutons peuvent être définis - La manette de jeu peut être interrogée - Les boutons Hollywood supportent les événements: Clic souris et survol du pointeur sur les boutons - Des calques peuvent être utilisés comme boutons - Le clavier peut être contrôlé - Des touches système peuvent être contrôlées - Des événements de fenêtre (le déplacement de fenêtre, redimensionnement, fermeture etc.) peuvent être contrôlés avec facilité - Lecture facile de l'ensemble des chaînes à partir du clavier - Fichier Pop Up, Chemin et requête de chaîne peuvent être utilisé pour demander des informations à l'utilisateur - Interface graphique pour contrôler le programme facilement @{APEN 16} Fonctions système : @{APEN 1} - Lire et écrire des fichiers - Contrôle total sur mes modes d'E/S de DOS (mis en mémoire tampon, sans tampon) - Lecture facile de répertoires entiers dans un tableau - Divers fonctions DOS (copier, effacer, renommer, le calcul crc32...) - Programmateur puissant pour synchroniser le script avec la musique - Fonctions faciles pour utiliser des tableaux comme des listes - Rechercher les informations sur des disques durs, mémoire... - Rendre votre programme multilingue en utilisant le support de la bibliothèque Locale (locale.library) de Hollywood - Commande date et heure - L'application peut s'ouvrir sur le Workbench ou son propre écran @ENDNODE @NODE Requirements "Guide Hollywood" @{APEN 4}@{b}ELEMENTS REQUIS@{ub} @{APEN 16} (1) version AmigaOS : @{APEN 1} Conditions minimales : - Kickstart 3.0 (V39) - AmigaOS(tm) 3.0 - CPU 68020 - carte graphique avec CyberGraphX ou Picasso96 Conditions recommandées : - Kickstart 3.1 (V40) - AmigaOS(tm) 3.9 - CPU 68040 - 32 mégaoctets de mémoire Fast ou plus Logiciels nécessaires optionnels : - AHI par Martin Blom pour la sortie audio - mpega.library par Stephane Tavenard pour la lecture mp3 - freetype2.library par l'équipe d'AROS pour la prise en charge des polices True Type (seulement requis sous AmigaOS3) - reqtools.library pour la fonction StringRequest() (pas sous AmigaOS 4; sous AmigaOS4 le StringRequest() fonctionne également sans reqtools.library) - pngalpha.library pour charger le canal alpha d'une image .PNG; elle est seulement exigé sur OS3.x classique; La prise en charge de canal alpha sous MorphOS, OS4 et AROS s'effectue avec picture.datatype - pngalpha.library pour sauvegarder des images .PNG; celle-ci est exigé sur tous les systèmes si vous souhaitez sauvegarder des images PNG puisque tous les datatypes PNG disponible ne supporte pas tous la sauvegarde d'image PNG - sound.datatype v41 par Stephan Rupprecht pour charger les échantillons de 16 bits (seulement requis sur AmigaOS3 ; MorphOS et OS4 supportent les échantillons de 16 bits avec sound.datatype); vous pouvez télécharger se datatype sur: http://www.stephan-rupprecht.de/ - plusieurs datatypes d'images, par exemple JPG, GIF, BMP pour charger ces formats - MUI pour l'interface graphique Hollywood @{APEN 16} (2) version Win32 @{APEN 1} - exige au moins Windows 2000 @{APEN 16} (3) version Mac OS @{APEN 1} - exige au moins Mac OS 10.4 (Tigre) @ENDNODE @NODE Package "Guide Hollywood" @{APEN 16}@{b}Le pack Hollywood@{ub} @{APEN 1} L'exécutable principal de Hollywood a été copié par l'outil d'installation dans le répertoire Hollywood:System. De plus, l'outil d'installation a également ajouté ce répertoire à votre chemin. Par conséquent, vous pouvez simplement taper "Hollywood" depuis la console et Hollywood sera exécuté. Veuillez noter que le programme principal Hollywood n'a pas d'interface graphique. Il reçoit seulement des arguments de console ou des tooltypes. Mais il existe un front-end pour Hollywood, disponible dans le répertoire racine du répertoire d'installation Hollywood. @{APEN 16} Interpréteur et joueur : @{APEN 1} l'exécutable principal de Hollywood est ce que nous appelons "l'interpréteur". Il peut lire vos fichiers de codes sources et les traduisent en code Hollywood binaire. La version d'Hollywood qui est liée à un exécutable que vous compilez avec Hollywood est une version spéciale.Cette version s'appelle "le joueur" puisqu'elle peut seulement exécuter le code binaire existant mais ne peut pas compiler de nouveaux codes sources en code binaire. Les exécutables du joueur ne sont pas accessibles à l'utilisateur. Ils sont entreposé dans la base système d'Hollywood, Hollywood.sys qui est également disponible dans Hollywood:System. @{APEN 16} Script : @{APEN 1} Les scripts Hollywood sont simplement des fichiers texte ASCII qui contiennent des déclarations que seul Hollywood peut interpréter. Ainsi, ils doivent suivre certaines règles qui sont expliquées dans cette documentation. Les scripts Hollywood utilisent le suffixe hws. @{APEN 16} Plugins : @{APEN 1} Les plugin sont enregistrées dans le répertoire Hollywood:Plugins. A chaque démarrage, Hollywood balayera ce répertoire et chargera tous les plugins qu'il trouve dans la mémoire. Les plugins Hollywood utilisent le suffixe hwp. @ENDNODE @NODE GUI "Guide Hollywood" @{APEN 16}@{b}Utilisation de l'interface graphique@{ub} @{APEN 1} L'utilisation de l'interface graphique devrait être auto-explicatif. Vous pouvez l'utiliser pour démarrer les exemples fournis avec Hollywood, démarrer vos propres scripts, ou compiler vos scripts. @ENDNODE @NODE ImportantInformation "Guide Hollywood" @{APEN 4}@{b}INFORMATION IMPORTANTE@{ub} @{APEN 1} Si vous voulez distribuer votre script, vous devez être sûr de l'avoir compilé avant @{APEN 4} @{b} il est interdit d'inclure l'interpréteur Hollywood dans votre package de données@{ub} @{APEN 1} Vous pouvez seulement distribuer votre application dans un des formats suivant: - comme exécutable ou applet compilé avec le compilateur Hollywood - comme code source @{APEN 4}@{b}mais sans inclure l'interpréteur Hollywood@{ub} @{b} l'interpréteur Hollywood est un programme commercial qui ne doit pas être distribué sous n'importe quelle forme. Rappelez-vous de ça.@{ub} @{APEN 1} Si vous voulez distribuer votre script, vous devez vous assurer que vous le compilez en tant qu'exécutable ou applet, ou de distribuer le code source de votre script (ceci exigera que l'utilisateur aie son propre interpréteur Hollywood). Vous pouvez également distribuer votre script sous forme d'applet Hollywood. L'avantage est que la taille de vos archives sera beaucoup plus petite parce que le joueur Hollywood ne sera pas inclus (l'utilisateur peut télécharger le joueur Hollywood librement disponible sur www.airsoftsoftwair.com et fait fonctionner votre applet en utilisant le joueur Hollywood). Voir le chapitre @{"les applets Hollywood" LINK Applets} pour plus d'information. Rappelez-vous également d'informer vos utilisateurs quels sont les éléments exigés de vos scripts compilés. Voir le chapitre @{"éléments requis" LINK Requirements}. L'utilisateur aura besoin de toutes les bibliothèques utilisées par Hollywood. De plus, ne pas oublier d'inclure toutes les données que votre application chargera. Cela comprend toutes les polices de caractères que votre script utilisera. @ENDNODE @NODE Compiler "Guide Hollywood" @{APEN 16}@{b}Utilisation du compilateur et du lieur de fichier@{ub} @{APEN 1} Le compilateur Hollywood peut être utilisé avec l'interface graphique @{"GUI" LINK GUI} ou @{"l'argument -compile" LINK ManualUsage} depuis la console (shell ou cli). Une fois exécuté, le compilateur lira le fichier script indiqué, le compilera et insérera le Joueur, une version spéciale du moteur d'Hollywood. Toutes les données externes qui sont déclarées en utilisant les @{"commandes préprocesseur" LIEN V6PrgPreproc} seront incorporés ( à moins qu'on lui déclare explicitement qu'un fichier ne doit pas être incorporé). Le format de l'exécutable peut être défini par l'argument @{"-exetype" LINK ManualUsage}. Cet argument peut indiquer le format CLASSIQUE, AMIGAOS4, WARPOS, MORPHOS,et AROS, WIN32, MACOS, MACOS86, ou APPLET. Dans la version 68k de Hollywood le -exetype est défini par défaut sur CLASSIQUE, dans AmigaOS4 -exetype est défini par défaut sur AMIGAOS4 et ainsi de suite. @{b}Note:@{ub} Avant de distribuer votre application, lisez les informations du chapitre @{"information importante" LIENT ImportantInformation}. Si vous utilisez beaucoup de données externes, votre exécutable pourrait devenir volumineux parce que Hollywood incorpora tous les fichiers indiqués avec les commandes préprocesseur. Si vous ne voulez pas incorporer des données externes à votre exécutable, vous pouvez utiliser l'argument "Link" qui est supporté par toute les commandes préprocesseur pour indiquer eu lieu de fichier de ne pas incorporer certains fichiers. Alternativement, vous pouvez charger les fichiers en utilisant les commandes normales de Hollywood au lieu des commandes préprocesseur. L'exécutable généré acceptera les mêmes @{"arguments de console" LINK ManualUsage} que le programme principal Hollywood. Par conséquent vous pouvez le démarrer par exemple avec une fenêtre sans bord en l'exécutant avec l'argument -borderless. @ENDNODE @NODE Applets "Guide Hollywood" @{APEN 16}@{b}Les applets Hollywood@{ub} @{APEN 1} Indépendamment des exécutables qui sont autonomes, vous pouvez également compiler vos scripts en Applet Hollywood. Ils sont beaucoup plus petits parce qu'ils ne contiennent pas le Joueur Hollywood. Les applet Hollywood peuvent être exécuté depuis l'interpréteur ou le Joueur Hollywood qui est gratuit et librement téléchargeable. L'avantage des Applet est que vous gagnez beaucoup d'espace disque puisque la taille du fichier est moins importante. Imaginez que vous voulez compiler votre script pour les sept plateformes supportées par Hollywood ( AmigaOS3, AmigaOS4, WarpOS, ainsi que AROS, Win32, et Mac OS ). Les Joueurs pour toutes ces plateformes réuni dans un seul et même fichier prend déjà plus de 5 Mega Octets, cela aurait comme conséquence d'énormes archives. Dans ce cas, il est plus judicieux de compiler votre script en Applet Hollywood. De plus, l'utilisateur peut simplement télécharger le Joueur Hollywood compatible avec la plateforme de l'utilisateur, ils sont librement disponible sur: http://www.airsoftsoftwair.com/ et utiliser votre Joueur pour exécuter l'applet. @{APEN 4} Attention, vous ne devez distribuer que votre applet. @{APEN 1} Pour compiler vos script en Applet avec Hollywood, indiquer juste APPLET dans @{"l'argument -exetype" LINK ManualUsage} ou utiliser l'interface graphique. @{APEN 16} Les Applets Hollywood auront comme suffixe .hwa. @{APEN 1} @ENDNODE @NODE APIChanges "Guide Hollywood" @{APEN 16}@{b}Changement dans l'API@{ub} @{APEN 1} ================================================================================= @{APEN 4} +++ Hollywood 4.0 +++ changement dans l'API change +++ information importante +++@{APEN 1} ================================================================================= Il y a eu quelques petits changements d'API sur Hollywood 4.0 très ressemblante aux anciennes versions, vous n'êtes pas obligé d'adapter vos scripts pour qu'ils fonctionne avec la version 4.0. Contrôler seulement les informations suivantes pour vous rendre compte si votre script exige une adaptation. - la syntaxe de SetPointer() a complètement changé. Elle n'accepte plus de nom de fichier mais vous devez d'abord indiquer la commande CreatePointer(). - Toutes les commande de la bibliothèque d'effets de transition effectue comme PlayAnim(), MoveXXX() et DisplayBGPicPart() utilise maintenant une nouvelle syntaxe. Cependant, l'ancienne syntaxe est toujours supporté pour des raisons de compatibilité. ================================================================================= @{APEN 4} +++ Hollywood 3.1 +++ changement dans l'API change +++ information importante +++@{APEN 1} ================================================================================= Il y a eu quelques petits changements d'API sur Hollywood 3.1 très ressemblante aux anciennes versions, vous n'êtes pas obligé d'adapter vos scripts pour qu'ils fonctionne avec la version 3.1. - Les deux points ( : ) ne sont plus supportés comme séparateur de commande. Dans Hollywood 1.x les deux points ont dû être utilisé pour séparer plusieurs commandes sur la même ligne, par exemple: ;Code Hollywood 1.x - @{APEN 4}@{b}PLUS SUPPORTE@{ub}@{APEN 1} x=100:y=200:width=50:height=50:Box(x, y, width, height, #RED) L'émulateur 1.x d'Hollywood a émulé ce comportement jusqu'à Hollywood 3.0. Dans Hollywood 3.1 il n'est maintenant plus supporté parce que les deux points sont nécessaires pour la programmation orientée objet. Donc vous devez mettre à jour vos scripts si vous utilisez toujours des deux points pour séparer plusieurs commandes sur une seule ligne. Depuis Hollywood 2.0, vous pouvez mettre autant de commandes sur une seule ligne si vous le désirez,ce qui signifie que le code ci-dessus pourrait être maintenant écrit comme ceci: x=100 y=200 width=50 height=50 Box(x, y, width, height, #RED) Cette méthode n'es pas très lisible et c'est pour cela que vous devez éviter de déclarer plusieurs commandes sur la même ligne. Naturellement, faites selon vos choix. Garder juste à l'esprit que Hollywood 3.1 n'émule plus le comportement des deux points de la version 1.x. - L'effet de transition #TYPEWRITER est maintenant annulé. C'était un effet qui pouvait seulement être utilisé sur les objets textes. Cependant, il créait une interface de police inutilement complexe donc inutile. Vous pouvez émuler le comportement de #TYPEWRITER en utilisant juste une série de commande Print(). ================================================================================= @{APEN 4} +++ Hollywood 3.0 +++ changement dans l'API change +++ information importante +++@{APEN 1} ================================================================================= Il y a eu quelques petits changements d'API sur Hollywood 3.0 très ressemblante aux anciennes versions, vous n'êtes pas obligé d'adapter vos scripts pour qu'ils fonctionne avec la version 3.0. - Si Hollywood 3.0 est démarré sans aucun argument, il s'ouvrira dans le mode fenêtre. Toutes les versions précédentes ouvraient le mode plein écran dans se type de cas, mais je pense qu'il est beaucoup plus sage qu'Hollywood s'ouvre en mode fenêtre parce que le mode plein écran ne pouvait pas fonctionner sur chaque système. - les argument de la ligne de commande sont maintenant utilisées différemment. Vous devez les préfixer avec le tiret (-). Dans les versions précédentes, vous deviez exécuter Hollywood come ci dessous: Hollywood script.hws WINDOW BORDERLESS A partir de cette version, ceci ne fonctionne plus. Maintenant vous devez utiliser des tirets. La méthode correcte pour exécuter Hollywood est la suivante: Hollywood script.hws -window -borderless Ce changement était nécessaire suite à l'ajout de la nouvelle commande GetCommandLine() qui vous permet d'utiliser avec vos propres arguments. - le deuxième argument de FileRequest() a été modifié. Précédemment, c'était une extension de fichier dans le format d'extension d'AmigaDOS. Maintenant il est également un filtre qui indique quels types de fichiers sera affiché par la requête. Ce changement était nécessaire en raison de l'élargissement des plateformes supporté par Hollywood. Ces nouveaux OS supporté sont Win32 et Mac OS et ils n'ont pas une prise en charge de filtre d'extensions de fichiers aussi élaboré que l'AmigaOS. - dans la version précédente le troisième argument facultatif de la commande OpenFile() est passée de nouveau à #MODE_READWRITE si elle n'est pas indiqué. Ceci a été modifié. Maintenant le mode par défaut est #MODE_READ. C'est une cassure de la vanité de l'API. Je pense juste que cela semble beaucoup plus raisonnable d'ouvrir des fichiers en mode non modifiable par défaut. ================================================================================= @{APEN 4} +++ Hollywood 2.5 +++ changement dans l'API change +++ information importante +++@{APEN 1} ================================================================================= Il y a eu quelques petits changements d'API sur Hollywood 2.5 très ressemblante aux anciennes versions, vous n'êtes pas obligé d'adapter vos scripts pour qu'ils fonctionne avec la version 2.5. - Le support de la bibliothèque ttengine.library a été enlevé. Naturellement Hollywood supporte toujours les polices de caractères TrueType. La seul chose que vous ne pouvez plus efectuer est d'utiliser SetFont() avec les fichiers *.ttf directement, c.-à-d.. SetFont("dh1:arial.ttf"); le code de Hollywood 2.0 Cette méthode ne fonctionne plus. Depuis Hollywood 2.5, vous pouvez seulement utiliser les polices de caractères TrueType qui ont été installés dans votre système à l'aide de FTManager ou d'un outil semblable. Vous les ouvrez comme si c'étaient des polices de caractères normales, c.-à-d.. SetFont("Arial Narrow.font") ; CORRECT DEPUIS LA VERSION 2.5 Vous devez l'écrire de cette façon parce que Hollywood 2.5 charge toute les polices de caractère TrueTypes avec la bibliothèque bullet.library qui est compatible respectivement avec l'interface ft2 (OS4) ou l'interface freetype2 (MorphOS, AROS, AmigaOS3). - La commande CheckEvent() a été retiré. Elle ne correspond plus dans le concept. Utiliser toujours WaitEvent() à la place. - Maintenant, la commande Plot() fonctionne seulement avec des calques désactivé. Les calques du type #PLOT ne sont plus réalisable. Il n'y avait aucun sens d'avoir des calques de taille 1x1. Si vous voulez vraiment utiliser un calque de 1x1, vous pouvez utiliser la commande Box() afin de tracer un pixel. - En raison du nouveau moteur de rendu de texte, il est maintenant obligatoire d'utiliser deux crochets dans les chaîne que vous indiquez dans les commandes Print(), TextOut() et CreateTextObject() quand vous voulez afficher des crochets. Par exemple, le code suivant Print("[Hello World]") ; code de Hollywood 2.0 entraînerait une erreur de syntaxe dans Hollywood 2.5 parce que le nouveau moteur de textes s'attend à une commande de formatage après les crochets. Donc, vous devez l'écrire comme suit : Print("[[Hello World]]") ; CORRECT DEPUIS LA VERSION 2.5 Alors votre code fonctionnera comme vous l'attendez. - Si le style de remplissage est placé à #FILLTEXTURE ou #FILLGRADIENT et que vous vous tracez en utilisant une valeur ARGB, maintenant ces styles de remplissage respecter également la valeur alpha.Ce n'était pas le cas dans Hollywood 2.0. - Si les calques sont activés et que vous utilisez une commande provenant de la bibliothèque de traçage ( par exemple Ellipse() ) et indiquent une couleur ARGB (c.-à-d. que vous voulez tracer avec de la transparence), Hollywood 2.0 créer un calque transparent pour vous comme si vous appeliez la commande SetLayerTransparency() avec l'octet A de la valeur ARGB comme une donnée de transparence. Ceci n'est plus utilisé de cette façon. Si vous tracez avec une couleur ARGB, Hollywood 2.5 ne donnera pas au calque une caractéristique de transparence, bien que maintenant le calque a naturellement un transparent, mais avec la version 2.5 la transparence est déjà généré dans les données graphiques (c.-à-d. le canal alpha) et n'est pas maintenu dynamiquement comme dans le cas de SetLayerTransparency(). - Jusqu'à Hollywood 2.0, RotateBrush() a toujours renvoyé une brosse de la taille maximale que la rotation de la brosse source pourraient occuper, c.-à-d. les maxs = la racine carré de (largeur * largeur + hauteur * hauteur). La nouvelle brosse assignée par Hollywood serait alors de largeur et hauteur 'maxs'. Maintenant, Ceci n'est plus d'actualité. La brosse est exactement aussi grande que se qu'elle doit contenir en graphisme. - Dans Hollywood 2.0, WriteMem() et ReadMem() utilisés toujours les E/S sans buffer tandis que toutes les autres commande DOS utilisées un buffer sur les E/S. Maintenant toutes les commandes ont été unifiées et elles utilisent tous un buffer sur les E/S par défaut. Avant, dans Hollywood 2.0, WriteMem() vidait toujours automatiquement le buffer avant de commencer l'opération d'écriture. Ceci n'est plus effectué depuis la version 2.5. Ainsi, si vous utilisez WriteMem()/ReadMem() dans vos script et que vous n'avez pas besoin du buffer de l'E/S comme dans la version 2.0, vous devrez d'abord utilser SetIOMode() pour changer le mode d'E/S sans buffer. Alors cela fonctionnera comme vous voulez l'utiliser mais rappellez-vous qu'il ne vide pas le buffer comme dans Hollywood 2.0. Et se rappeler cela, que une fois que vous utilisez SetIOMode() toutes les autres commandes DOS utiliseront également se mode d'E/S. Si vous voulez seulement que les E/S n'aient pas de buffer pour WriteMem() ou ReadMem() vous devez encore utiliser SetIOMode() après votre appel. Vous devez également utiliser FlushFile() manuellement si vous commutez buffer à sans buffer sur les E/S sur le même fichier. Sa semble assez compliqué, mais c' est vraiment facile. En effet, il vous donne le plein contrôle des commandes DOS qui peuvent devenir assez maniable. Voir la documentation de SetIOMode() pour plus d'information. - Jusqu'à Hollywood 2.0, TextOut() alignait automatiquement le texte si une constante spéciale de coordonnée comme #CENTER ou #RIGHT était indiqué en tant que coordonnée "x". Ceci n'est plus effectué de cette façon. Il y a un nouvel argument que vous pouvez utiliser pour spécifié l'alignement désiré. ================================================================================= @{APEN 4} +++ Hollywood 2.0 +++ changement dans l'API change +++ information importante +++@{APEN 1} ================================================================================= Bien que Hollywood 2.0 soit une mise à jour titanesque, seulement quelques modification étaient nécessaires sur l'API. Voici une liste d'éléments que vous devez modifier dans vos script: - Si vous appellez les commandes qui n'acceptent aucun argument mais qui retourne une valeur, vous devrez utiliser des parenthèses. Par exemple, le code suivant fonctionné dans la version 1.9 mais ne fonctionne plus dans la version 2.0: ; Incorrect x = MouseX y = MouseY Vous devez écrire le code ci-dessus comme: ; corriger x = MouseX() y = MouseY() La version incorrect ne déclenchera pas d'erreur de compilation. Ce code Hollywood est correct mais il efectue quelque chose de complètement différent: Il assigne la fonction MouseX() à la variable x et se n'est pas ce que vous voulez faire ici. - Maintenant, GetTimer() renvoie toujours la valeur en millisecondes. Dans Hollywood 1.x l'unité par défaut était des secondes.C'est une cassure de vanité de l'api. Naturellement, j'aurais pu gardé l'ancienne exécution, mais honnêtement, il n'y a personne qui veut une valeur de retour en secondes parce que c'est trop imprécis.Ainsi, j'ai décidé de faire une faveur aux programmeurs et de mettre les millisecondes par défaut, ainsi vous n'aurez pas à taper GetTimer(1, #MILLISECONDS) à chaque fois mais juste GetTimer(1). - Les commandes MoveBrush(), MoveTextObject(), MoveAnim() ne copie plus l'ancien objets. Par exemple, le code suivant ne fonctionne pas correctement dans la version 2.0 : MoveBrush(1, #LEFTOUT, #CENTER, #CENTER, #CENTER) Wait(100) MoveBrush(1, #CENTER, #CENTER, #RIGHTOUT, #CENTER) Avec Hollywood 1.x, ce code déplace la brosse 1 de l'exterieur gauche de l'écran au centre, attend 100 ticks, et déplace la brosse à la droite extérieur de l'écran. Dans Hollywood 2.0 ce code effectuerà la même chose, mais une copie de la brosse demeurera au centre de l'écran. C'est dû aux principaux changements du système de régénération d'affichage. Si vous voulez imiter le comportement de la version 1.x, utiliser MoveSprite() au lieu de MoveBrush(). - DisplayTransitionFX() ne peut plus être utilisé pour affiher images de fond transparentes; maintenant, commuter la transparence de BGPics peut seulement être effectué sans effet. C'est parce que Hollywood 2.0 utilise maintenant de vraies fenêtres transparentes sur MorphOS, OS4 et AROS. Ces fenêtres ont un calque où aucun graphisme ne peut être affiché. - Dans Hollywood 1.x, MixBrush() redimensionné les deux brosses à la même taille si elles étaient de dimensions différentes. Ce n'est plus d'actualité. MixBrush() mélange juste les parties qui correspondent et ne s'occupe pas du reste. - RotateBrush() créera maintenant un masque pour la brosse s'il elle n'en a pas. Vous n'avez plus besoin de le créer. - Si des calques sont activés et que vous utilisez InKeyStr(), seulement un calque du type #PRINT sera installé par InKeyStr(). Dans Hollywood 1.x, InKeyStr() effacé un calque #PRINT pour chaque caractère. ================================================================================= @{APEN 4} +++ Hollywood 1.9 +++ changement dans l'API change +++ information importante +++@{APEN 1} ================================================================================= Il y avait quelques changements mineurs de l'API d'Hollywood 1.9, qui sont énuméré ici : - les commandes EnableEventHandler() et DisableEventHandler() ont été enlevé. Elles pouvaient causer des erreurs parce que si vous les utilisiez, vous ne saviez pas quand vos procédures d'événement étaient appellées. Utiliser la nouvelle commande CheckEvent() - EnablePrecalculation() et DisablePrecalculation() ont été enlevé parce que la precalculation n'est plus supporté par Hollywood. L'argument et le tooltype PRECALCULATION est également été retiré. - WhileMouseOn() a eu quelques changements que vous ne verrez probablement pas mais qui dans certaines circonstances pouvaient créer des erreurs: Dans les versions antérieur, Hollywood pouvait immédiatement faire un saut arrière à votre boucle WaitEvent() après que l'événement ONBUTTONCLICK se soit produit. C'était un mauvais comportement. Maintenant il effectuera de nouveau un saut à votre commande WhileMouseOn() parce que la souris est au-dessus de votre bouton après que l'événement ONBUTTONCLICK se soit produite. Si vous voulez que Hollywood 1.9 se comporte comme Hollywood 1.0 et 1.5 , vous devez utiliser la nouvelle commande BreakWhileMouseOn() ================================================================================= @{APEN 4} +++ Hollywood 1.5 +++ changement dans l'API change +++ information importante +++@{APEN 1} ================================================================================= Malheureusement, j'ai dû effectué quelques modifications dans l'API du langage Hollywood dans la mise à jour 1.5. Si votre script ne fonctionne pas correctement sous Hollywood 1.5 mais qu'il fonctionne sous 1.0, alors, lire les informations suivante et adapter votre script. - la syntaxe constante a changé. Dans Hollywood 1.0 vous deviez juste indiqué les constantes par leur nom mais maintenant vous devez indiquer également le préfixe '#'. Ainsi vous devez indiquer par Exemple: #CENTER au lieu de CENTER et #BOLD au lieu de BOLD. Je suis désolé mais ce changement était absolument nécessaire. - Undo() ne fonctionnera pas jusqu'à ce que EnableLayers() soit indiqué. Si vous utilisez Undo() dans votre script, assurez-vous que l'exécution de EnableLayers() soit au début. - la syntaxe de PlaySample() a changé. Vous ne pouvez plus indiquer un canal pour la lecture. Hollywood effectuera tout pour vous. Indiquer juste le nombre d'échantillon et si il doit être lu en boucle ou non. - la syntaxe de PlayAnim() a changé. Maintenant elle fonctionne de manière synchrone. Ce changement était nécessaire parce que l'exécution de l'ancien PlayAnim() n'est plus adaptée dans le concept. Si vous devez jouer des animations de manière asynchrone, utiliser les liens de brosse des images et les afficher avec DisplayBrush(). Puisque PlayAnim() est maintenant synchrone, les commandes IsAnimPlaying() et WaitAnimEnd() ne sont plus exigés et ont été retirés. - ClearScreen() a été enlevé parce qu'il ne correspond plus au concept. - LoadModule() ne charge plus les modules THX, P61 ou MED. Le support de module se concentre maintenant sur le format de Protracker. Les autres formats de module ne peuvent pas être joués proprement en utilisant AHI. - Print() ne supportait plus l'anti-crénelage pour les polices de caractères TrueType. Ce changement était nécessaire pour rester compatible avec les calques. L'Anti-crénelage sera réintroduit pour tous les objets dans Hollywood 2.0. @ENDNODE @NODE VideoRecorder "Guide Hollywood" @{APEN 16}@{b}information sur l'enregistreur Video@{ub} @{APEN 1} Depuis Hollywood 4.0, il est possible de sauver les script comme des fichiers vidéo AVI. C'est utile par exemple si vous voulez créer des DVDs de vos scripts ou juste les visionner sur une plateforme qui n'est pas actuellement supporté par Hollywood. La sauvegarde de scripts Hollywood en tant que fichiers vidéo vous permet également de les importer dans des logiciels d'éditions vidéo pour des modifications ultérieure ou des conversions de format. L'enregistreur vidéo de Hollywood a été conçu avec l'idée de reproduire le comportement exact du script Hollywood dans un fichier vidéo. Ainsi, vous ne verrez aucune différence entre le fichier vidéo et le script Hollywood réel L'enregistreur vidéo de Hollywood essaye de chronométrer le script avec exactitude comme il devrait apparaître en temps réel. Par conséquent, ce n'est pas un problème pour l'enregistreur vidéo de traiter les scripts pour lesquels il est exigé une synchronisation exacte, par exemple une synchronisation avec la musique.L'enregistreur vidéo prête une attention particulière à sa et essais de créer un timing correcte sur tout les éléments du script. Pour activer l'enregistreur vidéo, vous devez indiquer l'argument @{"-videoout" LINK ManualUsage} ainsi qu'un nom de fichier pour que la vidéo soit créée. Hollywood débutera en mode d'enregistrement vidéo et les graphisme et les sons seront maintenant réorientés dans le jet vidéo. Donc, quand il est en mode d'enregistrement, aucun sons ne sera joué parce que les données sonores sont immédiatement rendues dans le jet vidéo. De plus, noter que certaines options sont négligées quand Hollywood est en mode d'enregistrement vidéo.Par exemple, en mode d'enregistrement vidéo Hollywood s'ouvrira toujours dans le mode fenêtre, jamais dans le mode plein écran même si vous lui indiquez.De Plus la fenêtre ne pas être redimensionnable, etc... Le fichier vidéo sauvegarder par l'enregistreur vidéo sera un fichier AVI 2.0 qui adhére à la norme d'OpenDML pour lire les fichiers vidéo à la volé de plus de 2 gigaoctets. Hollywood utilise actuellement le codec JPEG pour compresser les images vidéo. Les données audio sont insérées dans le fichier vidéo sans aucune compression. Vous pouvez définir la qualité du film JPEG en utilisant l'argument @{"-videoquality" LINK ManualUsage}. Pour obtenir le meilleur résultat, vous avez besoin d'ajuster quelques paramètres dans l'enregistreur vidéo que nous allons maintenant expliquer: 1) En premier, il est conseillé d'indiquer à l'enregitreur vidéo de combien d'image par second sera enregistré. Vous pouvez l'indiquer avec l'argument @{"-videofps" LINK ManualUsage}. La valeur que vous allez indiquer ici sera identique à la fréquence de votre boucle principale. Si votre boucle principale fonctionne à 25 images par seconde, par exemple en utilisant le code suivant: SetInterval(1, p_MainLoop, 1000\25) Ainsi votre fichier vidéo fonctionnera à 25 fps. Vous devais indiquer -videofps 25 sur la ligne de commande pour indiquer à l'enregistreur vidéo que vous voulez que votre vidéo a 25 images par seconde (Fps). 2) Vous pouvez indiquer une résolution de redimensionnement pour le fichier vidéo. N'oublier pas que la résolution de la vidéo ne peut pas être modifier mais seulement la résolution d'affichage de cette vidéo. Hollywood peut modifier la résolution de l'affichage à tout moment mais pour le fichier vidéo ceci n'est pas possible ainsi si la taille de l'affichage de Hollywood change tandis que le programme est en mode d'enregistrement vidéo, des graphismes seront redimensionnés pour maintenir la résolution vidéo correctement. Par défaut, la résolution vidéo serà la même que la résolution de la première image de fond. Si vous désirez utiliser une résolution différente, cependant, vous devez indiquer les arguments @{"-scalewidth" LINK ManualUsage} et @{"-scaleheight" LINK ManualUsage}. 3) votre script Hollywood doit suivre un certain modèle afin que l'enregistreur vidéo pour le sauvegarder comme un fichier vidéo. En particulier, l'enregistreur vidéo doit connaître quand son buffer d'image sera vidé dans le fichier vidéo. Normalement, il est vidé à chaque fois qu'il rencontre une commande d'attente. Par Exemple: @{"VWait() " LINK VWait} @{"Wait() " LINK Wait} @{"WaitEvent() " LINK WaitEvent} @{"WaitTimer() " LINK WaitTimer} etc. Il est nécessaire d'utiliser une de ces commandes ci-dessus dans votre script. Votre script doit utiliser un mécanisme de synchronisation, autrement, il ne peut pas être correctement converti dans un fichier vidéo. Les mécanismes de synchronisation suggéres l'utilisation de commandes d'intervalle qui sont exécutées un certain nombre de fois par seconde ou utiliser WaitTimer() ou VWait(). Lire le chapitre @{"mécanisme de synchronisation de script" LINK V6PrgG2KTiming} pour plus d'information sur l'importance d'utiliser se mécanisme. L'effacement du contenu du buffer d'image toutes les fois qu'une commande d'attente se produit s'appelle "la stratégie d'attente" qui est également la stratégie vidéo par défaut. Normalement, la stratégie d'attente conviens à toutes les situations. Avec des scripts correctement chronométrés, la stratégie d'attente fournit les meilleurs résultats.Dans quelques rares cas - ou pour la correction de bugs - vous pouvez utiliser la stratégie "raw" à la place. Quand @{"-videostrategy" LINK ManualUsage} est réglé avec "raw", l'enregistreur vidéo générera chaque image dans le flux vidéo que des attentes sont utilisées ou pas.Dans la plupart des cas, le résultat aura une mauvaise synchronisation vidéo, "raw" est très rarement utilisé. 4) en dernier, vous devez choisir si le pointeur de souris sera rendu dans le flux vidéo ou non. Par défaut, il est réglé avec "disabled" (désactivé) parce qu'en générant le pointeur de souris dans la vidéo n'a de sens que dans des situations spéciales, par exemple si vous créez une vidéo de demo où l'entrée d'utilisateur sera visible. Pour activer l'enregistrement du pointeur de souris, indiquer l'argument @{"-videopointer" LINK ManualUsage}. Tout les mouvements du pointeur de souris seront alors enregistrés dans le fichier vidéo. @ENDNODE @NODE AutoScalingInfo "Guide Hollywood" @{APEN 16}@{b}Information sur le moteur de redimensionnement d'Hollywood@{ub} @{APEN 1} Depuis Hollywood 4.0, il y a deux moteurs de redimensionnement disponibles que vous pouvez utiliser pour forcer votre script à fonctionner dans une résolution différente de celle pour laquelle il a été conçu.Par exemple, vous avez écrit un petit jeu en 320x240 de sorte qu'il ne ralentiise pas sur Amigas classique. Sur les Amigas moderne, cependant, 320x240 apparaîtra dans une petite fenêtre. vous pouvez maintenant utiliser les moteurs de redimensionnement d'Hollywood pour faire apparaître votre script en 640x480 ou 800x600 sans changer une seule ligne de votre code. Pour arriver à utiliser cette méthode, activer les moteur de redimensionnement d'Hollywood. Quand un moteur de redimensionnement est activé, votre script pensera qu'il est exécuté dans sa résolution originale. Cela veux dire, par exemple, que ces appelles ressemblent à largeur = GetAttribute(#DISPLAY, 0, # ATTRWIDTH) taille = GetAttribute(#DISPLAY, 0, # ATTRHEIGHT) Ceci retournera toujours la résolution de 320x240 même si votre script fonctionne maintenant dans une résolution complètement différente. Il est évident qu'un tel comportement soit nécessaire pour uniformisé c.-à-d. s'assurer que le script fonctionne dans la nouvelle résolution. Votre script ne se rendra jamais compte qu'un moteur de redimensionnement est activé. Le moteur de redimensionnement sera complètement installé d'une manière transparente dans votre script. @{APEN 16}@{b}Hollywood offre deux moteurs de redimensionnement:@{ub} (1) moteur de redimensionnement automatique @{APEN 1} Vous pouvez activer ce moteur de redimensionnement en indiquant l'argument -autoscale. Ce moteur de redimensionnement est un moteur de redimensionnement de bas niveau qui redimensionnera simplement toutes les sorties graphique d'Hollywood aux nouvelles dimensions. Pour cette raison, le moteur automatique de redimensionnement fonctionnera avec tous les scripts Hollywood sans exceptions. Les inconvénients du moteur de redimensionnement automatique sont a) qu'il peut être consommateur de ressource CPU dans certaines circonstances, b) qu'il redimensionne les graphismes vectoriels comme des images Bitmap, se qui signifie que, par exemple, les polices TrueType ou les graphismes de primitives seront détériorés et perdront donc en qualité, et c) que la méthode est plus lent parce que la totalité l'affichage doit être régénéré même si seulement un Pixel a changé. @{APEN 16} (2) moteur de redimensionnement de calque @{APEN 1} Le moteur de redimensionnement de calque est plus sophistiqué, c'est un moteur de redimensionnement de haut niveau que vous pouvez activer avec l'argument -layerscale. Ce moteur de redimensionnement a) est beaucoup plus rapide que le moteur de redimensionnement automatique parce que les calques sont seulement redimensionné qu'une seule fois, b) offre une qualité plus élevée pour les graphismes de vectoriels (c.-à-d. les primitives graphiques, texte) qui peuvent être redimensionné sans perte de qualité, et c) affiche plus rapidement parce que seul des parties de l'affichage doivent être régénérées. L'inconvénient du moteur de redimensionnement de calque est que cela fonctionne seulement quand Hollywood est en @{"mode calque" LINK EnableLayers}. Vous ne pouvez pas exécuter @{"DisableLayers()" LINK DisableLayers} quand le moteur de redimensionnement de calque est activé.Ainsi, si vous voulez utiliser le moteur de redimensionnement de calque, l'intégralité de votre script doit fonctionner avec les calques activés. Entre ces deux descriptions l'option (2) pourrait être la meilleur solution, mais ce n'est pas nécessairement le cas. En fait, le moteur de redimensionnement automatique reste de visu suffisamment agréable dans la plupart des cas. Le moteur de redimensionnement de calque est seulement important pour les projets tel les présentations qui seront affiché à des résolutions HDTV ou semblable. Dans ce cas, il est important que les graphismes vectoriel soient proprement redimensionné en mode vectoriel de sorte que le résultat affiché soit de qualité. Dans des circonstances normal d'utilisation, utiliser le moteur automatique de redimensionnement devraient remplir la plupart de vos exigences. Ne soyez pas découragé par le fait qu'il est plus lent que le moteur de graduation de calque puisque sur les nouveaux systèmes, vous ne ressentirez pratiquement aucun ralentissement. Vous pouvez définir la résolution initiale de redimensionnement pour les deux arguments -autoscale/-layerscale en indiquant les arguments -scalewidth et -scaleheight. Si vous n'indiquez pas -scalewidth et -scaleheight, les moteurs de redimensionnement ne seront pas activé avant que l'utilisateur redimensionne la fenêtre. Enfin, vous pouvez indiquer l'argument -smoothscale pour activer l'anti-aliasing dans le redimensionnement pour les graphismes Bitmaps, se qui les rend plus beaux, mais plus lent. @ENDNODE @NODE ManualUsage "Guide Hollywood" @{APEN 16}@{b}Manuel d'utilisation@{ub} @{APEN 1} Si vous ne voulez pas utiliser le GUI, vous pouvez également exécuter Hollywood à partir de la console. La ligne de commande pour utiliser Hollywood à partir de la console est: Hollywood Les options suivantes sont disponibles (lire ci-dessous pour une explication détaillé de chacune de ces options): -autoscale -backfill -bestfit -borderless -brush -brushfile -compile -compress -depth -endcolor -exetype -fakefullscreen -fixed -fullscreen -hidepointer -hidetitlebar @{APEN 4}[Seulement sur Amiga OS et Mac OS]@{APEN 1} -layerscale -linkfiles -mastervolume @{APEN 4}[Seulement sur Amiga OS] @{APEN 1} -modeid @{APEN 4}[Seulement sur Amiga OS] @{APEN 1} -nohide -nomodeswitch -nosound -overwrite -ownscreen -pictrans -picxpos -picypos -pubscreen @{APEN 4}[Seulement sur Amiga OS] @{APEN 1} -quiet -scalepicture -scalewidth -scaleheight -scrwidth -scrheight -sizeable -smoothscale -startcolor -stayactive -usequartz @{APEN 4}[Seulement sur Mac OS] @{APEN 1} -usewpa @{APEN 4}[Seulement sur Amiga OS] @{APEN 1} -videofps -videoout -videopointer -videoquality -videostrategy -window -wpamode @{APEN 4}[Seulement sur Amiga OS] @{APEN 1} Ces options peuvent être spécifiées comme arguments de ligne de commande quand Hollywood ou un programme compilé par Hollywood est exécuté à partir de la console. AmigaOS :Ces options pourraient également être utilisées comme tooltypes au cas où un script Hollywood ou le programme est exécuté à partir du WorkBench. Insérer juste les options dont vous avez besoin dans les tooltypes dans votre icône d'application. Mac OS :Si vous exécutez un programme Hollywood à partir de Finder, vous pourrez encore utiliser tous ces options. Il faut juste les écrire dans l'entré du dictionnaire "CFBundleExecutableArgs" dans le fichier Info.plist de votre application. @{APEN 16} @{b}Voici les descriptions détaillées pour chaque commande:@{ub} -autoscale : @{APEN 1} * Si vous indiquez cet argument, le moteur automatique de redimensionnement sera activé. Cela signifie que votre script peut être affiché dans toute les résolutions définissable et cela fonctionne automatiquement. Vous ne devez effectuer aucun changements dans votre code. Si le redimensionnement automatique est activé, Hollywood fera croire à votre script qu'il fonctionne toujours dans sa résolution d'origine mais en réalité il obtiendra upscaled ou downscaled (selon la résolution de redimensionnement choisie). Vous pouvez indiquer la résolution de redimensionnement automatique initiale en utilisant les arguments -scalewidth et -scaleheight. La résolution de redimensionnement peut être modifiée par l'utilisateur à n'importe quel momment en redimensionnant fenêtre Hollywood (ne pas oublier de rendre votre fenêtre redimensionnable en utilisant la @{"commande préprocesseur @DISPLAY" LINK atDISPLAY} ou l'argument -sizeable). Si vous n'indiquez pas -scalewidth et -scaleheight au démarrage, le script sera démarrer sans redimensionnement automatique, mais le redimensionnement automatique sera activé dès que l'utilisateur redimensionnerà la fenêtre. Si vous voulez utiliser anti-aliasing dans le redimensionnement automatique (plus lent) indiquer l'argument -smoothscale. Hollywood soutient une autre moteur de redimensionnement qui peut être activé par l'argument -layerscale (voir ci-dessous). D'autres informations sur les moteurs automatiques de redimensionnement sont disponible @{"ici" LINK AutoScalingInfo}. @{APEN 16} -backfill : @{APEN 1} * Cet argument vous permet d'indiquer un type de remplissage pour l'affichage d'Hollywood. Si vous indiquez cet argument, Hollywood remplira l'écran entièrement. peut être un des mots-clés suivants : color : remplir l'arrière plan avec la couleur indiquée dans l'argument -startcolor picture : afficher la brosse indiquée dans l'argument -brush/-brushfile comme image de fond (centrée); si vous indiquez également l'agument -startcolor, l'arrière plan sera effacé avec cette couleur; si vous indiquez -endcolor, le fond sera effacé avec un dégradé de couleurs allant de -startcolor à -endcolor gradient : affiché un dégradé comme arrière plan (avec un dégradé de couleurs allant de -startcolor à -endcolor) texture : afficher la brosse indiquée dans l'argument de -brush/-brushfile comme une texture Comme vous pouvez le voir, tous les types de remplissage exigent un argument additionnel comme paramètre. Vous devez utiliser les arguments : -brush, -brushfile, -startcolor, et -endcolor (comme documenté ci-dessus). @{APEN 16} -bestfit : @{APEN 1} * Indiquer cet argument et Hollywood choisira automatiquement un mode d'écran pour vous. Hollywood utilise les dimensions de la première image de fond pour déterminer quel mode d'écran s'adapte le mieux à votre script. Vous pouvez en plus indiquer l'argument de profondeur (Nombre de couleurs) -depth. @{APEN 16} -borderless : @{APEN 1} * Si vous indiquez cet argument, Hollywood ouvrira une fenêtre sans bordures. C'est particulièrement utile pour les fenêtres transparentes. @{APEN 16} -brush : @{APEN 1} * Seulement requis en lien avec -Backfill "texture" ou "picture". Indiquer le nombre de la brosse à utiliser avec le mode de remplissage. Vous pouvez également utiliser -brushfile au lieu de cet argument (si vous ne voulez pas déclarer la brosse dans votre script). @{APEN 16} -brushfile : @{APEN 1} * Seulement requis en lien avec -Backfill "texture" ou "picture". Indiquer le nom du fichier de la brosse à utiliser avec le mode de remplissage. Vous pouvez utiliser également l'argument -brush au lieu de celui-ci. @{APEN 16} -compile : @{APEN 1} * Si vous indiquez cet argument, Hollywood convertira votre script en exécutable. Vous devez utiliser cette option si vous voulez publier votre script. Votre script ne sera pas exécuté. Il sera compilé et sauvé dans le . Utiliser l'argument -exetype pour indiquer la plateforme sur laquelle votre exécutable sera compatible. @{APEN 16} -compress : @{APEN 1} * Vous pouvez utiliser cet argument pour permettre la compression des projets Hollywood. Si cet argument est indiqué, Hollywood compressera les applet et les executables. Cet argument peut seulement être uyilisé en lien avec -compiler. @{APEN 16} -depth : @{APEN 1} * Cet argument doit être indiqué si vous voulez que Hollywood s'ouvre dans un mode plein écran. Cet argument indique à Hollywood la profondeur de couleur pour le mode plein écran (les profondeurs valides sont 15.16.24 et 32).Si vous n'indiquez pas cet argument, Hollywood utiliserà la profondeur de l'écran de bureau. @{APEN 16} -endcolor : @{APEN 1} * Seulement requis en lien avec -Backfill "gradient". la est une couleur indiqué au @{"format RGB" LINK RGBInfo} (par exemple $$FF0000>pour le rouge). Peut être également indiqué avec -Backfill "picture". Cela créera un dégradé derrière l'image. @{APEN 16} -exetype : @{APEN 1} * Seulement requis en lien avec -compiler. Cet argument indique le format de l'exécutable que le compilateur Hollywood créera. Il peut être "classic" pour des executables d'AmigaOS3 680x0, "amigaos4" pour AmigaOS4 PPC, "warpos" pour les executables mélange-binaires WarpOS, "morphos" pour MorphOS, "aros" pour i386 AROS, "macos" pour le PPC Mac OS, "macos86" pour Mac OS I386, "win32" pour Windows 32 bits , ou "applet" pour un fichier Hollywood universel qui peut être démarré sur tous les systèmes avec un Joueur Hollywood. Cet argument est par défaut sur "classic" dans la version 68k d'Hollywood. Dans la Version WarpOS Cet argument est par défaut sur "warpos" et ainsi de suite. @{APEN 16} -fakefullscreen : @{APEN 1} * Cet argument vous permet de mettre Hollywood dans un faux mode de plein écran. Ceci signifie que Hollywood s'ouvrira sur le dessus de bureau mais la fenêtre de remplissage sera configuré pour protéger complètement le bureau. l'utilisateur aura l'impression d'être en plein écran, bien qu'il fonctionne sur le bureau. @{APEN 16} -fixed : @{APEN 1} * Si vous indiquez cet argument, la fenêtre Hollywood sera fixe sur l'écran, se qui signifie que vous ne pourrez pas la déplacer.C'est utile quand Hollywood s'ouvre en mode plein écran. @{APEN 16} -fullscreen : @{APEN 1} * C'est un argument inclus pour le côté pratique.Il active automatiquement toutes les options dont vous avez besoin pour mettre Hollywood en mode plein écran. @{APEN 16} -hidepointer : @{APEN 1} * Si vous indiquez cet argument, le pointeur de souris sera automatiquement caché dès que Hollywood basculera en mode plein écran ou un faux mode de plein écran. Cet argument a un avantage face à la commande @{"HidePointer()" LINK HidePointer}, c'est qu'il cache seulement le pointeur de souris en mode plein écran. Si Hollywood s'ouvre dans le mode fenêtre, le pointeur de souris restera afficher puisque cacher le pointeur de souris en mode fenêtre créé habituellement une confusion chez l'utilisateur. @{APEN 16} -hidetitlebar : @{APEN 4}[Seulement sur Amiga OS et Mac OS] @{APEN 1} * Cet argument cache la barre de titre de l'écran utilisé. Il fait seulement effet quand Hollywood s'ouvre sur son propre écran ou quand vous utilisez comme -backfill sur l'écran Workbench. @{APEN 16} -layerscale : @{APEN 1} * Si vous indiquez cet argument, le moteur de redimensionnement de calque sera activé. Cela signifie que votre script peut être montré dans toute les résolution disponible et ceci fonctionne automatiquement - vous n'avez pas besoin de modifié votre code. Cependant, le moteur de redimensionnement de calque fonctionnera seulement si les @{"calques sont activés" LINK EnableLayers}. En mode de redimensionnement de calque, les calques sont adapté automatiquement à la nouvelle résolution et Hollywood fera croire à votre script qu'il est toujours exécuté dans sa résolution originale, ainsi votre script est exécuté exactement de la même manière que sans redimensionnement de calque. L'avantage du redimensionnement de calque est que le graphisme vectoriel (c.-à-d. les primitives graphiques, les textes TrueType) seront redimensionnés en mode vectoriel de sorte qu'il n'y ait aucune perte de la qualité même si vous modifiez la résolution de votre script de 320x240 en 1280x1024. Vous pouvez indiquer la résolution initiale de redimensionnement de calque en utilisant les arguments -scalewidth et -scaleheight (voir ci-dessous). La résolution de redimensionnement peut être modifié par l'utilisateur à tout moment en redimensionnant la fenêtre Hollywood (ne pas oublier de rendre votre fenêtre redimensionnable en utilisant la @{"commande préprocesseur @DISPLAY" LINK atDISPLAY} ou l'argument -sizeable). Si vous n'indiquez pas -scalewidth et -scaleheight au démarrage, le script sera démarré sans redimensionnement de calque, mais le redimensionnement de calque sera activé dès que l'utilisateur redimensionnerà la fenêtre.Si vous voulez utiliser l'anti-aliasing dans le redimensionnement de calque (plus lent), indiquer l'argument -smoothscale. Hollywood supporte un autre moteur de redimensionnement qui peut être activé en indiquant l'argument -autoscale (voir ci-dessus). D'autres informations sur les moteurs de redimensionnement sont disponible @{"ici" LINK AutoScalingInfo}. @{APEN 16} -linkfiles : @{APEN 1} * Cet argument est seulement utilisé quand -compile est également indiqué. Vous pouvez utiliser cet argument pour incorporer des fichiers dans votre applet ou exécutable. Votre script chargera automatiquement ces fichiers dans votre applet ou exécutable. Cette méthode est une alternative à l'utilisation des commandes préprocesseur pour incorporer des fichiers dans votre applet ou exécutable. Si vous ne voulez pas utiliser les commandes préprocesseur pour incorporer des fichiers dans votre applet ou exécutable, utiliser -linkfiles pour indiquer vos choix. Vous devez indiquer un fichier de base de données dans -linkfiles dans le paramètre . le fichier de base de données est un fichier simple qui contient une liste de fichiers à incorporer dans l'applet ou l'exécutable qui sera compilé par Hollywood. Vous devez spécifier un seul fichier par ligne dans le fichier de base de données. Les fichier de données doivent être identique aux données que vous utilisez dans votre script. Par exemple, si il y a une commande 'LoadBrush(1, "data/menu.iff")' dans votre script et que vous voulez que le fichier "data/menu.iff" soit incorporé dans votre applet ou exécutable, vous devez le spécifié dans la base de données grce à -linkfiles. Mais vous devez utiliser les mêmes données, c.-à-d. que vous devez utiliser "data/menu.iff". L'indication "DH0:MyScripts/CoolGame/data/menu.iff" dans la base de données ne fonctionnera pas. Les données utilisées dans le fichier de base de données de lien et dans le script doivent être les mêmes, sinon Hollywood ne reconnaîtra pas les fichiers qu'il doit charger. @{APEN 16} -mastervolume : @{APEN 4}[Seulement sur Amiga OS] @{APEN 1} * Cet argument vous permet de définir le volume sonore principal qu'Hollywood utilisera. Utiliser cet argument seulement si vous entendez un défaut sonore quand Hollywood joue des sons. Normalement, vous ne devez pas utiliser une autre valeur. Le volume principal peut s'échelonner de 0 à 64. @{APEN 16} -modeid : @{APEN 4}[Seulement su Amiga OS] @{APEN 1} * L'argument id indique le mode d'écran que Hollywood ouvrira. Si vous n'indiquez pas cet argument, Hollywood ouvrira une requête vous demandant le mode d'écran à utiliser. Si vous indiquez -modeid, ajouter également l'argument -depth. @{APEN 16} -nohide : @{APEN 1} * Si vous indiquez cet argument, l'utilisateur ne sera pas capable de cacher l'écran d'Hollywood, c.-à-d. que la fenêtre Hollywood n'aura pas de bouton de réduction. Cet argument n'affecte pas les commandes @{"ShowDisplay()" LINK ShowDisplay} and @{"HideDisplay()" LINK HideDisplay}. Vous ne pourrez pas cacher et encore moins voir l'affichage en utilisant ces commandes. @{APEN 16} -nomodeswitch : @{APEN 1} * Si vous indiquez cet argument il sera impossible de commuter entre le mode fenêtre et le mode plein écran en vous servant des touches de raccourcis COMMAND+RETURN. Si -nomodeswitch est indiqué, Hollywood restera toujours dans son mode d'affichage initiale et aucun commutateur entre le mode fenêtre et le mode plein écran sera effectué. @{APEN 16} -nosound : @{APEN 1} * Cet argument neutralise toutes les commandes sonores Hollywood. Hollywood sera démarré en mode muet. @{APEN 16} -overwrite : @{APEN 1} * Si vous indiquez cet argument, Hollywood écrasera automatiquement les fichiers existants quand -compile est utilisé. Normalement, Hollywood vous demandera de confirmer l'écrasement des fichiers existants dans le mode -compile. vous pouvez supprimer la confirmation en indiquant cet argument. @{APEN 16} -ownscreen : @{APEN 1} * Cet argument est une alternative à l'argument -fullscreen. Il forcera Hollywood à s'ouvrir en mode plein écran, mais lui ne placera aucun autres arguments. Vous aurez toujours le contrôle d'autres arguments comme -borderless, -fixed, -backfill etc... Par exemple, vous pouvez utiliser cet argument si vous voulez un fond d'écran blanc au lieu du noir, -fullscreen vous donnera toujours un fond d'écran noir mais en utilisant -ownscreen ainsi que -backfill "color" et -startcolor "$$ffffff" vous pouvez obtenir un affichage en plein écran avec un fond d'écran blanc. Vous pouvez utiliser les arguments -scrwidth et -scrheight pour indiquer la taille désirée pour l'affichage en plein écran. Et vous pouvez utiliser -depth pour indiquer la quantité de couleur pour le mode plein écran. @{APEN 16} -pictrans : @{APEN 1} * Seulement possible avec -backfill "picture".Cet argument vous permet d'assigner une couleur de transparence à votre image. Par défauts à #NOTRANSPARENCY. @{APEN 16} -picxpos : -picypos : @{APEN 1} * Seulement possible avec -backfill "picture". Vous pouve z utiliser ces deux arguments pour indiquer la position où l'image de fond sera affichée. Défauts à #CENTRE. @{APEN 16} -pubscreen : @{APEN 4}[Seulement sur Amiga OS] @{APEN 1} * Si il est indiqué, Hollywood s'ouvrira sur l'écran public spécifié par le au lieu de l'écran de bureau. @{APEN 16} -quiet : @{APEN 1} * Si vous indiquez cet argument, Hollywood n'affichera aucune information durant son démarrage. @{APEN 16} -scalepicture : @{APEN 1} * Seulement possible avec -backfill "picture". Cet argument indique à Hollywood de redimensionner l'image de fond indiqué à la taille de l'image de fond de la fenêtre de telle façon qu'elle la remplisse complètement. @{APEN 16} -scalewidth : -scaleheight : @{APEN 1} * Ces deux arguments peuvent être utilisés en liaison avec -autoscale/-layerscale pour indiquer les dimensions initiale du moteur de redimensionnement. Vous pouvez indiquer une valeur numérique en Pixel (par exemple -scalewidth 1280 -scaleheight 1024) ou un redimensionnement en pourcentage (par exemple -scalewidth 200% -scaleheight 200%). Lire la documentation de -autoscale/-layerscale pour plus d'information sur le moteur de redimensionnement de Hollywood. @{APEN 16} -scrwidth : -scrheight : @{APEN 1} * Ces deux arguments peuvent être utilisés en liaison avec -ownscreen pour spécifier les dimensions du mode plein écran qu'ouvrira Hollywood. Si vous n'indiquez pas ces arguments, Hollywood choisira un mode plein écran qui s'adaptera mieux à votre écran.Si vous indiquez 0 en tant que et , Hollywood utilisera les dimensions de l'écran de bureau pour le mode plein écran. @{APEN 16} -sizeable : @{APEN 1} * Si vous indiquez cet argument, Hollywood ouvrira sa fenêtre avec un gadget sur le côté droit en bas de la fenêtre. Ce gadget sera invisible si votre fenêtre n'a pas des bords mais il sera présent. @{APEN 16} -smoothscale : @{APEN 1} * si -autoscale ou -layerscale est activé et que vous indiquez -smoothscale, toutes les opérations de redimensionnement utiliseront l'anti-aliasing (lissage de Pixel). cette options améliore la qualté de redimensionnement mais la rend également plus lente. Lire la documentation de -autoscale/-layerscale pour plus d'information sur les moteurs de redimensionnement de Hollywood. @{APEN 16} -startcolor : @{APEN 1} * Seulement utilisé avec -backfill "gradient" ou "color". est une couleur au @{"format RGB" LINK RGBInfo} (par exemple $00FF00 pour le vert). Peut être également utilisé avec -backfill "picture"; l'image de fond sera rempli par la couleur. @{APEN 16} -stayactive : @{APEN 4} * (retiré depuis Hollywood 2.0) @{APEN 16} -usequartz : @{APEN 4}[Seulement sur Mac OS] @{APEN 1} * Indique à Hollywood d'utiliser le quartz 2D pour le rendement de graphiques. Par défaut, Hollywood utilise QuickDraw parce que c'est beaucoup plus rapide (cependant désapprouvé). Si vous avez des problèmes de graphismes sur Mac OS, vous pouvez essayer cet argument. @{APEN 16} -usewpa : @{APEN 4}[Seulement sur Amiga OS] @{APEN 1} * Indique à Hollywood d'utiliser les drivers bitmap indépendant au lieu des drivers standard de l'OS. Les drivers bitmap indépendants sont normalement plus lent que ceux de l'OS standard excepté sur WinUAE et AROS qui ne peuvent tous les deux fermer avec efficacité les Bitmaps de l'OS. Donc, sur WinUAE et AROS, -usewpa est activé automatiquement afin d'accélérer Hollywood. Si vous ne voulez pas utilisé cette méthode, indiquer -wpamode 0. Note: -usewpa est un argument de bas niveau qui est ici principalement pour essai. Normalement, vous n'en aurez pas l'utilité. @{APEN 16} -videofps : @{APEN 1} * Seulement utilisé avec -videoout. Si -videoout est activé, -videofps peut être utilisé pour indiquer à Hollywood combien d'images par seconde (FPS) aurà la vidéo qui doit être enregistré. Si vous ne l'indiquez pas, 50 images par seconde seront utilisées comme valeur par défaut. @{APEN 16} -videoout : @{APEN 1} * Activer le dispositif d'enregistrement vidéo intégré de Hollywood. Si -videoout est indiqué, Hollywood sauvera votre script dans un dossier vidéo AVI que vous pourrez, par exemple, graver sur un DVD. Pour en savoir plus sur l'enregistreur vidéo, cliquez @{"ici" LINK VideoRecorder}. @{APEN 16} -videopointer : @{APEN 1} * Seulement utilisé avec - videoout. Si vous indiquez -videopointer le pointeur de souris sera généré dans le flux vidéo.Par défaut, quand vous utilisez l'enregistreur vidéo, le pointeur de souris n'apparaîtra pas dans la vidéo. Si vous avez besoin d'afficher le pointeur de souris dans la vidéo ( par exemple pour démontrer l'interaction d'un utilisateur), indiquer cet argument. Pour en savoir plus sur l'enregistreur vidéo, cliquez @{"ici" LINK VideoRecorder}. @{APEN 16} -videoquality : @{APEN 1} * Seulement utilisé avec -videoout. Si -videoout est activé, -videoquality peut être utilisé pour indiquer le niveau de compression pour les images vidéos. La qualité est spécifiée en pourcentage, donc les niveaux de qualités valides s'étendent de 0 à 100. 90 est la valeur par défaut qui génére un fichier vidéo de haute qualité qui peut par contre utilisé un espace disque assez conséquent. Si vous voulez avoir un plus petit fichier vidéo, vous pouvez essayer d'utiliser un niveau de moins bonne qualité. Pour en savoir plus sur l'enregistreur vidéo, cliquez @{"ici" LINK VideoRecorder}. @{APEN 16} -videostrategy : @{APEN 1} * Seulement utilisé avec -videoout. Si -videoout est activé, -videostrategy peut être utilisé pour indiquer la stratégie qu'Hollywood utilisera en convertissant un script Hollywood dans un fichier vidéo. Actuellement, vous pouvez indiquer ici "wait" et "raw". Par défaut Hollywood utilise la stratégie "wait". Pour en savoir plus sur l'enregistreur vidéo, cliquez @{"ici" LINK VideoRecorder}. @{APEN 16} -window : @{APEN 1} * Si vous indiquez cet argument, Hollywood ouvrira sa fenêtre sur le dessus du bureau au lieu du mode plein écran. Il est activé par défaut. @{APEN 16} -wpamode : @{APEN 4}[Seulement sur Amiga OS] @{APEN 1} * si -usewpa est activé, cet argument peut être utilisé pour définir le driver du mode Bitmap indépendant. Indiquer 0 désactive -usewpa, 1 active le mode DIB 32 bits, et 2 active le mode DIB conforme au WorkBench. il est réglé à 1 par défaut se qui donner le meilleure résultat. Note: -wpamode est un argument de bas niveau ce qui est principalement ici pour des questions de test. Normalement, vous n'aurez pas à utiliser cet argument. @ENDNODE @NODE ToDo "Guide Hollywood" @{APEN 16}@{b}A faire@{ub} @{APEN 1} Voici quelques idées qui sont sur ma liste à faire: - une bibliothèque qui vous permet d'insérer des éléments d'interface graphique dans vos scripts (c.-à-d. une interface avec gadtools.library) - support de la rotation des objets textes - support des mitres et la ligne biseautée joignent des types (actuellement seulement arrondis joindre type soutenu) - support d'AROS PPC - support du flux vidéo; un api approprié sera ici exigé - support des palettes de couleurs d'image: le dithering serait nécessaire en générant des données RGB aux palettes de brosses - la vitesse de toutes les commandes de transition devrait être redéfini en millisecondes au lieu d'un type fait sur commande; cela aiderait à chronométrer les scripts correctement - effets de transition sur les textes - une version pour PowerUP ? - une version qui peut rendre à la palette examine ?était possible dans 1.x et enlevé dans 2.0 mais pourrait être reimplemented tout à fait facilement bien qu'il soit totalement lent - plus d'option Contacter moi par @{"mail" LINK Contact} si vous avez quelques bonnes idées que je pourrais incorporer dans Hollywood. @ENDNODE @NODE Philosophy "Guide Hollywood" @{APEN 16}@{b}A propos d'Hollywood@{ub} @{APEN 1} La philosophie d'Hollywood est d'offrir une plateforme facile mais puissante qui peut être utilisé pour écrire des programmes performant en très peu de temps. Le langage utilisé pour programmer avec Hollywood est très simple pour les débutants mais également avec assez d'option que le programmeur expérimenté appréciera. Vous pouvez programmer avec Hollywood grce à une sorte de basic simplifié mais il est également possible plonger dans un monde entièrement orienté objet avec Hollywood. L'étendu du jeu de commandes avec presque 400 fonctions incorporées fournit au programmeur tous les outils pour créer des logiciels étonnant avec Hollywood. Il y a presque rien que vous ne pouvez pas faire avec Hollywood. Sur ce, Hollywood est une couche d'application multimédia multi-plateforme, qui signifie que vous pouvez exécuter vos programmes sur des plateformes différentes sans changer une seul ligne du code, et il est même possible de compiler des exécutables pour ces plateformes. Par exemple, vous pouvez compiler des applications Mac OS avec votre installation AmigaOS 3.1. Tout cela fait d'Hollywood l'outil ultime pour le programmeur multimédia. La version Amiga de Hollywood a été développé sous SAS/C 6.58 (version 68k), VBCC (version de WarpOS), GCC 2.95.3 (version de MorphOS) et GCC 4.0.2 (AmigaOS4). De plus les programmes suivants ont été utilisés: GoldED Studio AIX, Directory Opus 4, PPaint 7, CyberGuard, C yberGraphX 4, MUI. Le développement principale a été créé sur un Pegasos 2 avec un CPU G4 à 1Ghz et Morphos 1.4.5. Les autres développement sur un Amiga 1200 équipé d'une carte Blizzard PPC 603e à 240Mhz avec le SCSI, un CPU 68060 et une carte graphique BVision PPC avec 82Mo de RAM. Hollywood a été largement testé sur CyberGraphX 3 et 4, Picasso96, MorphOS, AmigaOS4, AROS, DraCo, Amithlon, WinUAE. Hollywood n'accéde pas directement sur le matériel. Il respecte tous les systèmes et utilise les fonctions seulement compatible système. La version Mac Os a été développée sur un Mac Mini à 1,5 Ghz avec Mac OS 10.4 (tigre) et sur un iMac Intel 2.4 gigahertz en utilisant Mac OS 10.5 (léopard). Le code a été écrit en utilisant l'éditeur de texte TextMate de Allan Odgaard. Hollywood a été compilé en utilisant GCC fourni avec le SDK Mac OS d'Apple. La version Win32 a été développée sur Pentium IV à 2.6 utilisant Windows Home Edition avec les derniers service packs. Le code a été écrit avec le fameux UltraEdit de IDM Comp. Hollywood a été compilé en utilisant Microsoft Visual C. @ENDNODE @NODE Credits "Guide Hollywood" @{APEN 16}@{b}Remerciement@{ub} @{APEN 1} Hollywood a été écrit par Andreas Falkenhahn. Mais je n'aurais pas pue le faire jusqu'ici sans aide de beaucoup de personnes que je voudrais mentionner ici. Un merci spéciale à Timm S. Müller pour ses conseils essentiels. Un grand merci à l'équipe de Lua 5.0.2 d'avoir créé ce puissant langage léger: Roberto Ierusalimschy, Waldemar Celes et Luiz Henrique de Figueiredo. Un merci pour Frank Wille de m'avoir aider pour le fonctionnement de la version WarpOS sans se laisser tomber SAS/C pour les parties de code 68k. Merci à Alexandre Pfau pour la traduction de l'énorme documentation en Allemand bien que la version allemande soit arrêté maintenant parce que sa représente trop de travail Mercis à Grzegorz Kraszewski, Martin Blom, Tomasz Wiszkowski, Kimmo Pekkola, Olaf Barthel, Thomas Richter, Christoph Gutjahr, Jean-Yves Auger, Ralph Schmidt, Detlef Würkner, Stephan Rupprecht, Frank Mariak, Jacek Piszczek et à tous les bêtas testeurs et à tous ceux qui devraient être ici mais qui on été oublié. @ENDNODE @NODE MailingList "Guide Hollywood" @{APEN 16}@{b}Mailing list@{ub} @{APEN 1} Lazar Zoltan a installé une mailing list pour les utilisateurs d'Hollywood. Il y a beaucoup d'utilisateurs Hollywood qui peuvent vous aider grce aux questions que vous pouvez poser au sujet de la programmation avec Hollywood. Naturellement, l'auteur d'Hollywood est également présent sur la liste et essayera de vous aider. La mailing list a été installée dans le groupe Yahoo. Vous pouvez vous y inscrire avec votre compte Yahoo. Visite juste la page de groupe à l'URL suivant: @{APEN 16} http://groups.yahoo.com/group/airsoft_hollywood/ @{APEN 1} Malheureusement, le mode du groupe est actuellement activé à "inviter seulement" et le groupe Yahoo ne permet pas la désactivation de cette option. Malheureusement, vous pouvez seulement vous joindre au groupe que grce à une invitation. Envoyer juste un E-mail à andreas@airsoftsoftwair.de et je vous enverrez une invitation ainsi vous pourrez vous joindre à notre liste de discution. * * * Les utilisateurs Allemand peuvent aller jeter un coup d'oeil "à la page d'utilisateurs Hollywood" maintenu par Helmut Haake. Elle offre un bon nombre de codes sources et d'ateliers et a également un forum où vous pouvez poser vos questions. Voici le lien : @{APEN 16} http://www.amiga-resistance.info/homepage/hollywood/index.html @{APEN 1} @ENDNODE @NODE Contact "Guide Hollywood" @{APEN 16}@{b}Contacter Moi@{ub} @{APEN 1} Si vous devez me contacter, utiliser cette adresse : Andreas Falkenhahn Un der Trift 2 36132 Eiterfeld-Arzell L'Allemagne Email :andreas@airsoftsoftwair.de WWW :http://www.airsoftsoftwair.com/ @ENDNODE @NODE FAQ "Guide Hollywood" @{APEN 16}@{b}Questions fréquement posées@{ub} @{APEN 1} Cette section répond à quelques questions fréquemment posées. A lire avant d'envoyer un mail, une des réponse ci-dessus résolvera peut être votre problème. Q : Y a il outil de création visuel pour les programmes Hollywood ou je doit éditer chaque script en utilisant un éditeur de texte? A : Oui, il y a un programme appelé le Hollywood Designer qui a une interface puissante WYSIWYG pour créer vos propres présentations Hollywood. Aller voir sur http://www.airsoftsoftwair.com/ pour plus d'informations sur ce logiciels d'aide à la programmation Hollywood. Q : Les sorties audios d'Hollywood subissent une distortion. Qu'est-ce qui ne va pas ici? A : Vérifier vos préféfrences AHI. Vous devez régler le volume principal dans vos préférences avancés AHI à "avec coupure (with clipping)". Si ceci n'arrange rien, essayer de réduire le volume principal dans Hollywood, en utilisant l'argument @{"MASTERVOLUME" LINK ManualUsage}. Vous pouvez également diminuer le volume principal dans les préférences de l'interface grafique. Vous devez également désactiver l'écho et le mode surround si il y a encore des problèmes sur le son. Assurez-vous également que vous avez réglé la fréquence pour votre driver son correctement. Il devrait être réglé au moins à 22050 hertz. Q : J'obtiens toujours l'erreur "Plus de mémoire (Out of memory)" et je n'ai pas de carte Graphique. A : Si vous avez un peu de capacité mémoire FAST (16 méga-octets ou plus) vous pouvez utiliser le patch FBlit téléchargeable à partir d'Aminet. Elle patchera votre système pour alloué les données graphiques d'être placé dans la mémoire FAST. Hollywood utilisera également la mémoire FAST pour tous ses graphiques et donc vous ne devrez plus obtenir l'erreur "Plus de mémoire". Note :Il est important que vous activiez le patch AllocBitMap() de FBlit. Cela peut être effectué en incluant La tche Hollywood dans la liste de tche ou en utilisant le mode d'exclusion de FBlit excluent. Si vous n'activez pas le patch AllocBitMap() pour Hollywood, cela ne fonctionnera pas. Q : J'obtiens toujours l'erreur "Plus de mémoire (Out of memory)" et j'ai pourtant une carte Graphique. A : Installer une mémoire plus rapide. Q : Je voudrais ajouter mes propres commandes à Hollywood en utilisant un plugin.Y a il un SDK disponible? A : Pas pour le momment. Une sortie de SDK est programmé pour la version 2.0. Q : Quand le support d'expression sera ajouté? A : Se sera programmé pour la version 2.0. Q : Comment puis-je interrompre les présentations qui sont exécutées dans une fenêtre qui n'a pas le gadget de fermeture? A : Appuyer simultanément sur CTRL et la touche C. Q : Où puis-je demander de l'aide? A : Nous avons une mailing list où vous pouvez accéder via: airsoft_hollywood@yahoogroups.com. Voir @{"here" LINK MailingList}pour plus d'informations Q : Cette documentation est-elle disponible dans un format imprimable comme le pdf? A : Désolé, pas encore. Mais ceci est programmé dans l'avenir. Q : J'ai trouvé un bug. A : Veuillez me contacter. @ENDNODE @NODE V6PrgOprPri "Guide Hollywood" @{APEN 16}@{b}Opérateur : priorités@{ub} @{APEN 1} Voici une liste complète de tous les opérateurs disponibles et de leurs priorités. Inutile de les connaître par coeur. Dans le doute, utiliser les parenthèses. Elles rendent votre programme plus lisible puisque personne ne sait que l'opérateur de déplacement vers la gauche a une plus haute priorité que le bit ou un opérateur. +-------------------------------------------------------------------------+ + @{b}priorité@{ub} @{b}opérateur@{ub} @{b}Description@{ub} + +-------------------------------------------------------------------------+ @{APEN 1}+ 12 ^ Exposant + @{APEN 9}+ 11 - Négative + @{APEN 1}+ 11 ~ Négative au niveau des bits + @{APEN 9}+ 11 Not Non Logique + @{APEN 1}+ 10 * Multiplication + @{APEN 9}+ 10 / Division + @{APEN 1}+ 10 \\ Division d'entiers + @{APEN 9}+ 10 % Reste de la division + @{APEN 1}+ 9 + Addition + @{APEN 9}+ 9 - Soustraction + @{APEN 1}+ 8 << Déplacement vers la gauche + @{APEN 9}+ 8 >> Déplacement vers la droite + @{APEN 1}+ 7 & Fonction And au niveau des bits + @{APEN 9}+ 6 ~ Fonction Xor au niveau des bits + @{APEN 1}+ 5 | Fonction Or au niveau des bits + @{APEN 9}+ 4 .. Concaténation + @{APEN 1}+ 3 = Egalité + @{APEN 9}+ 3 <> Inégalité + @{APEN 1}+ 3 < Inférieur à + @{APEN 9}+ 3 > Supérieur à + @{APEN 1}+ 3 <= Inférieur et égal à + @{APEN 9}+ 3 >= Supérieur et égal à + @{APEN 1}+ 2 And Fonction logique And + @{APEN 9}+ 1 Or Fonction logique Or + @{APEN 1} +-------------------------------------------------------------------------+ @ENDNODE @NODE V6PrgOprStrng "Guide Hollywood" @{APEN 16}@{b}Concaténation de chaîne@{ub} @{APEN 1} +-------------------------------------------------------------------------+ + @{b}BINAIRE@{ub} + +-------------------------------------------------------------------------+ + @{b}Opérateur@{ub} @{b}Description@{ub} @{b}Exemple@{ub} + +-------------------------------------------------------------------------+ + .. Concaténation a .. b + +-------------------------------------------------------------------------+ L'opérateur de concaténation de chaîne peut être utilisé pour relier deux chaînes dans une nouvelle chaîne. Puisque Hollywood effectue la @{"conversion d'un nombre en une chaîne" LINK V6PrgStrNumConv} automatiquement, vous pouvez même concaténer deux nombres. Le résultat sera toujours une chaîne bien que. Exemples : DebugPrint("Hello" .. " World") ; prints "Hello World" DebugPrint(5 .. " + " .. 5 .. " = " .. 10) ; prints "5 + 5 = 10" Cet opérateur est également utile si vous voulez écarter une chaîne de plusieurs lignes. Par Exemple: DebugPrint("Mon Programme v1.0\\n" .. "(c) par moi 2005\\n" .. "Presser RETURN pour démarrer!") @ENDNODE @NODE V6PrgOprBitw "Guide Hollywood" @{APEN 16}@{b}Opérateur sur les bits@{ub} @{APEN 1} Hollywood supporte les opérateurs sur les bits suivants : +-------------------------------------------------------------------------+ + @{b}BINAIRE@{ub} + +-------------------------------------------------------------------------+ + @{b}Opérateur@{ub} @{b}Description@{ub} @{b}Exemple@{ub} + +-------------------------------------------------------------------------+ @{APEN 1}+ << Déplacement vers la gauche (logique) a << b + @{APEN 9}+ >> Déplacement vers la droite (logique) a >> b + @{APEN 1}+ & And Binaire a & b + @{APEN 9}+ ~ Xor Binaire a ~ b + @{APEN 1}+ | Or Binaire a | b + +-------------------------------------------------------------------------+ +-------------------------------------------------------------------------+ + @{b}UNAIRE@{ub} + +-------------------------------------------------------------------------+ + @{b}Opérateur@{ub} @{b}Description@{ub} @{b}Exemple@{ub} + +-------------------------------------------------------------------------+ + ~ Négation Binaire ~a + +-------------------------------------------------------------------------+ Les opérateurs sur les bits vous permettent de travailler avec des expressions au niveau des bits. Ces opérations sont tous limités à des valeurs 32 bits. Voici une description des opérateur sur les bits: L'opérateur de déplacement vers la gauche (<<) change tous les bits de l'opérande a vers la gauche de b fois. Les bits sans valeurs sur le côté droit du nombre créé par cette opération seront complété avec des zéros (déplacement logique). b ne doit pas être négatif. Déplacement du nombre a de x fois vers la gauche, est égal à multiplier ce numéro par 2^x. Mais bien sur, le déplacement est beaucoup plus rapide que de le multiplier. Exemples : 7 << 1 = %111 << 1 = %1110 = 14 (7 * 2^1 = 14) 256 << 4 = %100000000 << 4 = %1000000000000 = 4096 (256 * 2^4 = 4096) L'opérateur de déplacement vers la gauche (<<) change tous les bits de l'opérande a vers la droite de b fois. Les bits sans valeurs sur le côté gauche du nombre créé par cette opération seront complétés avec des zéros (déplacement logique). Si vous avez besoin d'un décalage arithmétique (des bits sans valeur seront complétés avec le bit de poids fort), utiliser la fonction @{"Sar()" LINK Sar}. b ne doit pas être négatif. Déplacer un nombre de X fois est égal à la division de ce numéro par 2^x. Mais bien sùr, le déplacement est beaucoup plus rapide que de diviser si un résultat de nombre entier est assez précis pour vous. Exemples : 65 >> 1 = %1000001 >> 1 = %100000 = 32 (65 \\ 2^1 = 32) --> division d'entier 256 >> 4 = %100000000 >> 4 = %10000 = 16 (256 \\ 2^4 = 16) ---> division d'entier Au niveau du bit, les opérateurs And, Xor et Or sont aussi fondamentalement identique que les opérateurs logiques And/Xor/Or avec la différence que &, ~ et | travail au niveau des bits, c.-à-d. qu'ils comparent chacun des 32 bits des opérandes a et b et règlent les bits dans le résultat selon cette comparaison. L'opérateur And réglera le bit dans la valeur de renvoi si des bits dans les opérandes a et le b sont réglés sur cette position. L'opérateur de Xor réglera le bit dans le valeur de renvoi si un des deux bits est à 1 mais pas si les deux sont à 1. L'opérateur Or réglera le bit dans la valeur de renvoi si un ou les deux opérandes ont le bit réglé sur cette position. @{APEN 16} table de vérité : @{APEN 1} +-------+-------+-------------+-------------+-------------+ + Bit 1 + Bit 2 + bit1 & bit2 + bit1 ~ bit2 + bit1 | bit2 + +-------+-------+-------------+-------------+-------------+ + 1 + 1 + 1 + 0 + 1 + + 1 + 0 + 0 + 1 + 1 + + 0 + 1 + 0 + 1 + 1 + + 0 + 0 + 0 + 0 + 0 + +---------------+-------------+-------------+-------------+ Exemples : %10011001 & %11101000 = %10001000; Opérateur And sur les bits %10011001 ~ %11101000 = %01110001; Opérateur Xor sur les bits %10011001 | %11101000 = %11111001; opérateur Or sur les bits L'opérateur unaire d'inversion (~) fera au niveau du bit une inversion du nombre qui est utilisé. Tous les bits seront inversés. Veuillez noter que la valeur doit toujours être converti en nombre entier de 32 bits avant l'inversion. Ainsi, vous pourrez utiliser beaucoup plus de bits. Par Exemple: ~%00000000 = %11111111111111111111111111111111 ~%10111001 = %11111111111111111111111101000110 Pour l'utilisation de 1 dans une inversion, il faut utiliser simplement l'opérateur binaire And (&) sur la valeur donnant le résultat. Par exemple, si vous voulez seulement faire inverser 8 bits comme dans l'exemple ci-dessus, utiliser 255 en valeur binaire : ~%00000000 & %11111111 = %11111111 ~%10111001 & %11111111 = %01000110 @ENDNODE @NODE V6PrgOprLogic "Guide Hollywood" @{APEN 16}@{b}Opérateurs logique@{ub} @{APEN 1} Hollywood supporte les Opérateurs logiques suivants : +-------------------------------------------------------------------------+ + @{b}BINAIRE@{ub} + +-------------------------------------------------------------------------+ + @{b}Opérateur@{ub} @{b}Description@{ub} @{b}Exemple@{ub} + +-------------------------------------------------------------------------+ + And Fonction logique And a And b + + Or Fonction logique Or a Or b + +-------------------------------------------------------------------------+ +-------------------------------------------------------------------------+ + @{b}UNAIRE@{ub} + +-------------------------------------------------------------------------+ + @{b}Opérateur@{ub} @{b}Description@{ub} @{b}Exemple@{ub} + +-------------------------------------------------------------------------+ + Not Fonction logique Not Not a + +-------------------------------------------------------------------------+ Les opérateurs And et Or utilise une évaluation. Ceci signifie que si le premier opérande définit déjà le résultat, le deuxième opérande ne sera pas pris en compte. Par exemple, si le premier opérande de l'expression And est Faux (0), alors la deuxième opérande n'a pas besoin d'être évalué puisque l'expression entière ne pourra pas être vraie. La même chose s'applique à l'expression Or si la première opérande est vrai (<>0). Alors l'expression sera toujours vraie - peux importe la valeur de la deuxième opérande. Note : And et Or ne retourne pas de constante True(1) si elles sont vraies. And retourne le deuxième opérande si c'est vrai et Or retourne la première opérande si c'est vrai. Par Exemple: a = 5 And 4 ; a = 4 a = 5 And 0 ; a = 0 a = 0 And 4 ; a = 0 b = 5 Or 4 ; b = 5 b = 5 Or 0 ; b = 5 b = 0 Or 4 ; b = 4 L'opérateur unaire Not réalisera une inversion sur son opérande. Le résultat sera toujours True (1) ou False (0). Si il est utilisé sur une chaîne, il aura comme résultat True si la chaîne est vide (""). Par Exemple: a = Not True ; a = 0 (False) a = Not False ; a = 1 (True) a = Not 5 ; a = 0 (False) a = Not Not True ; a = 1 (True) a = Not "Hello" ; a = 0 (False) a = Not "" ; a = 1 (True) Note : L'opérateur Not a une priorité élevé. Vous aurez besoin de parenthèses dans la plupart des cas. Par exemple, ce code ne fonctionne pas: If Not a = -1 ; Faux! Hollywood le traduira comme ceci If (Not a) = -1 puisque l'opérateur Not a une priorité plus élevé que l'opérateur d'égalité. Mais évidemment, cette traduction n'a aucun sens parce que le résultat de l'expression entre parenthèse (Not a) sera toujours 0 ou 1 mais jamais -1. Par conséquent, si vous voulez vérifier que a n'est pas à -1, vous devrez utiliser des parenthèses autour de l'expression avec la priorité la plus basse: If Not (a = -1) ; correct! Pour visualiser le tableau qui montre la prioritée des Opérateurs, voir le chapitre @{"priorités des opérateurs" LINK V6PrgOprPri}. @ENDNODE @NODE V6PrgOprRelat "Guide Hollywood" @{APEN 16}@{b}Opérateurs de relation@{ub} @{APEN 1} Hollywood supporte les opérateurs de relation suivants: +-------------------------------------------------------------------------+ + @{b}BINAIRE@{ub} + +-------------------------------------------------------------------------+ + @{b}Opérateur@{ub} @{b}Description@{ub} @{b}Exemple@{ub} + +-------------------------------------------------------------------------+ @{APEN 1}+ Not Fonction logique Not Not a + @{APEN 9}+ = Egale a = b + @{APEN 1}+ <> différent de a <> b + @{APEN 9}+ < inférieur à a < b + @{APEN 1}+ > supérieur à a > b + @{APEN 9}+ <= inférieur ou égale à a <= b + @{APEN 1}+ >= supérieur ou égale à a >= b + +-------------------------------------------------------------------------+ Chacun de ces Opérateurs compare les opérandes a et b et renvoie True si la condition correspond, sinon False. Noter que vous pouvez seulement comparer des valeurs de même type. La conversion automatique d'un nombre en chaîne ne fonctionne pas dans se cas la! Les Opérateurs d'égalité peuvent être utilisés avec tous les types, c.-à-d. que vous pouvez également comparer des fonctions et des tableaux. Les Opérateurs de commande (< > <= >=) fonctionnent seulement avec des nombres et des chaînes. Si vous comparez des chaînes, Hollywood effectuera une comparaison alphabétique. Par Exemple: r = ("Hello" < "World") ---> True parce que H vient avant W dans l'alphabet r = ("Commodore" < "Amiga") ---> False parce que C vient après A dans l'alphabet @ENDNODE @NODE V6PrgOprArith "Guide Hollywood" @{APEN 16}@{b}Opérateurs arithmétique@{ub} @{APEN 1} Hollywood supporte les Opérateurs arithmétiques suivants : +-------------------------------------------------------------------------+ + @{b}BINAIRE@{ub} + +-------------------------------------------------------------------------+ + @{b}Opérateur@{ub} @{b}Description@{ub} @{b}Exemple@{ub} + +-------------------------------------------------------------------------+ @{APEN 1}+ + Addition a + b + @{APEN 9}+ - Soustraction a - b + @{APEN 1}+ * Multiplication a * b + @{APEN 9}+ / Division de réel a / b + @{APEN 1}+ \\ Division d'entie a \\ b + @{APEN 9}+ % Reste de division a % b + @{APEN 1}+ ^ Exposant a ^ b + +-------------------------------------------------------------------------+ +-------------------------------------------------------------------------+ + @{b}UNAIRE@{ub} + +-------------------------------------------------------------------------+ + @{b}Opérateur@{ub} @{b}Description@{ub} @{b}Exemple@{ub} + +-------------------------------------------------------------------------+ + - Négation -a + +-------------------------------------------------------------------------+ Voici seulement une brève description de chaque opérateur : Addition: a + b - Ajoute a et b, par exemple 5 + 3 = 8 Soustraction : a - b - Soustrait b de a, par exemple 10 - 5 = 5 Multiplication : a * b - Multiplie a par b, par exemple 10 * 8 = 80 Division réelle : a/b - Fait une division exacte. Le résultat peut être une valeur à virgule. Par exemple 5/2 = 2.5 - b ne doit pas être 0 Division de nombre entier : a \\ b - Divise a par b. La partie décimale sera effacée, par exemple 5 \\ 2 = 2 - b ne doit pas être 0 Reste de Division : a % b - Renvois le reste en nombre entier de la division a \\ b, par exemple 5 % 2 = 1 - b ne doit pas être 0 Exposant : a ^ b - Calcule a exposant b, par exemple 2 ^ 8 = 256 Négation : - a - réalise une inversion de a, par exemple --5 = 5 @ENDNODE @NODE V6PrgOpr "Guide Hollywood" @{APEN 16}@{b}Expressions et Opérateurs@{ub} @{APEN 1} Une expression est une combinaison d'opérandes et d'opérateurs. S'il y a au moins un opérande et un opérateur, alors nous parlons d'une expression. Hollywood évalue les expressions avant de livrer les résultats dans une fonction. Une expression peut être une constante ou une variable, selon si elle contient des variables ou pas. Par exemple, 5 + 3 est une expression. Les opérandes sont 5 et 3 et l'opérateur est +. -1 est également une expression parce que nous avons un opérande et un opérateur. Normalement, chaque opérateur a besoin de deux opérandes mais l'opérateur d'inversion (-) est unaire et a besoin pour cette raison que d'un opérande. Vous pouvez utiliser des parenthèses dans les expressions pour indiquer à Hollywood ce qui sera d'abord évalué. Dans la ligne suivante a = (3 + 4) * 5 Hollywood va additionner d'abord 3 et 4 et multiplier ensuite le résultat de la somme par 5. Si vous n'insérez pas les parenthèses dans le code ci-dessus, Hollywood effectuera d'abord 4 * 5 et additionnerait ensuite 3 au résultat parce que l'opérateur de multiplication (*) a une priorité plus élevé que l'opérateur d'addition (+). Pour visualiser le tableau qui montre la prioritée des Opérateurs, voir le chapitre @{"priorités des opérateurs" LINK V6PrgOprPri}. Voici une synthèse de tous les Opérateurs disponible : @{"Opérateurs Arithmétique " LINK V6PrgOprArith} + - / \\ * % ^ unaire: - @{"Opérateurs de relation " LINK V6PrgOprRelat} = <> < > <= >= @{"Opérateurs logique " LINK V6PrgOprLogic} And Or Not @{"Opérateur sur les bits " LINK V6PrgOprBitw} << >> & | @{"Concaténation de chaîne " LINK V6PrgOprStrng} .. @ENDNODE @NODE V6PrgCharacterCst "Guide Hollywood" @{APEN 16}@{b}Constantes de caractère@{ub} @{APEN 1} Les constantes de caractère sont habituellement utilisées pour obtenir la valeur ASCII d'un caractère d'une manière simple. Si vous indiquez un caractère dans des guillemets (''), Hollywood remplacera ce caractère par sa valeur ASCII. Ainsi, les constantes de caractère sont toujours du type de données @{"Nombre" LINK V6PrgTypeNumber}. Voici un Exemple: DebugPrint('A') ; affiche 65 Vous pouvez également mettre des séquences d'échappement dans une constante de caractère. Par Exemple: DebugPrint('\\n') ; affiche 10 Pour plus d'information sur les séquences d'échappement disponible avec Hollywood, lire la documentation @{"type de donnée dans une chaîne" LINK V6PrgTypeString}. Vous pouvez même mettre plus d'un caractère dans une constante de caractère. Hollywood supporte l'évaluation jusqu'à quatre caractères dans une constante. Ainsi vous pourriez également convertir des séquences comme celle-ci : formnum = 'FORM' ; formnum = 1179603533 (46 4F 52 4D ... F O R M) L'identifiant FORM du fichier IFF a une valeur de $464F524D. Mais les constantes de caractère avec plus d'un caractère sont utilisé rarement. @ENDNODE @NODE V6PrgConst "Guide Hollywood" @{APEN 16}@{b}Déclaration Const@{ub} @{APEN 1} @{b}Const@{ub} # = La commande Const vous permet de déclarer une nouvelle constante. le nom que vous spécifiez dans doit être préfixé avec le caractère d'informations (#). doit être une expression constante (!) , c'est à dire que vous ne devez pas utiliser de variables ici. Par Exemple: Const #MYCONSTANT = (5 * 10) / 2 ; #MYCONSTANT = 25 Const #MYCONSTANT2 = #MYCONSTANT * 10 ; #MYCONSTANT2 = 250 Const #MYCONSTANT3 = b * 5 ; Ne fonctionne pas! Le dernier exemple ne fonctionnera pas parce qu'une variable est utilisée alors que l'expression est une constante. Alternativement, peut également être une expression d'une chaîne de constante. Par exemple: Const #PRGVERSTRING = "$VER: MyProgram 1.0 (13.04.2005)" @ENDNODE @NODE V6PrgConstants "Guide Hollywood" @{APEN 16}@{b}Constantes@{ub} @{APEN 1} Des constantes, comme le nom l'indique, sont des valeurs sous un nom personnalisé par l'utilisateur qui ne peut pas être modifié après leur première initialisation. Les valeurs qu'elles transportent sont fixes pendant l'exécution du script. Comme tous les éléments de langage, Hollywood ne distingue pas les caractères minuscules et majuscules, mais elles devraient être écrites en lettres capitales pour des raisons de lisibilité. Les constantes que vous indiquez dans votre script doivent également être écrite avec un préfixe de caractère d'informations (#) pour les discerner des variables. Les constantes True et False sont ici des exceptions, elles n'ont pas besoin d'avoir un préfixe de caractère d'informations parce qu'elles sont les parties élémentaires du langage de script Hollywood. Toutes autres constantes sont juste des ajouts pour des commandes et c'est pour cette raison qu'il y a une nécessité de les préfixer. Les constantes doivent être des nombres ou des chaînes. Vous pouvez également déclarer vos propres constantes en utilisant la déclaration @{"Const" LINK V6PrgConst}, par Exemple: Const #MYCONSTANT = 5 * 5 Si vous utilisez cette déclaration, vous devrez toujours l'indiquer au début de votre script parce que c'est une déclaration globales qui ne peut pas être changée pendant l'exécution du script. @ENDNODE @NODE V6PrgInbuiltCst "Guide Hollywood" @{APEN 16}@{b}Constantes incorporées@{ub} @{APEN 1} Les constantes incorporées sont utilisées par beaucoup de commandes comme descripteurs pour une action spéciale, pour cette raison leurs fonctions sont différentes de constante à constante. Si une commande exige une constante spéciale comme argument (par exemple @{"SetFontStyle()" LINK SetFontStyle} utilise les constantes #BOLD, #ITALIC, #NORMAL et #UNDERLINED), ces constantes sont décrites dans la documentation pour cette commande. De plus il y a quelques constantes qui peuvent être indiquées à chaque fois qu'une commande Hollywood vous demande les coordonnées de x ou y. Ces constantes sont des " constantes de position ". Elles vous permettent de spécifier facilement les positions les plus utilisées. Les constantes suivantes de position sont incorporées dans Hollywood : @{APEN 16} @{b}Les constantes suivantes peuvent être utilisées en tant que coordonnée x:@{ub} @{APEN 1} #CENTER : spécifie le centre de votre écran (= (displaywidth-objectwidth) / 2) #LEFT : spécifie le bord gauche de votre écran (= 0) #LEFTOUT : spécifie la gauche extérieure de votre écran (= 0-objectwidth) #RIGHT : spécifie le bord droit de votre écran (= displaywidth-objectwidth) #RIGHTOUT : spécifie la droite extérieure de votre écran (= displaywidth+objectwidth) @{APEN 16} @{b}Les constantes suivantes peuvent être utilisées en tant que coordonnée y:@{ub} @{APEN 1} #CENTER : spécifie le centre de votre écran (= (displayheight-objectheight)/2) #TOP : spécifie le bord supérieur de votre écran (= 0) #TOPOUT : spécifie le haut extérieur de votre écran (= 0-objectheight) #BOTTOM : spécifie le bord inférieur de votre écran (= displayheight-objectheight) #BOTTOMOUT : spécifie la base extérieure de votre écran (= displayheight+objectheight) Ces constantes rendent très facile le positionnement de vos objects. Par exemple si vous voulez afficher la brosse 1 au centre de l'écran, il faut juste écrire @{"DisplayBrush(1, #CENTER, #CENTER)" LINK DisplayBrush} et voila. Vous pouvez même affiner les positions en soustrayant et en ajoutant des valeurs à ces constantes. Par exemple, DisplayBrush(1, #CENTER, #CENTER + 25) affiche une brosse à 25 Pixel en dessous du centre vertical de l'écran. Il y a également quelques constantes qui vous permettent un accès assez aisé aux couleurs fondamental. Les constantes suivantes de couleur sont actuellement déclarées par défaut : #BLACK, #MAROON, #GREEN, #OLIVE, #NAVY, #PURPLE, #TEAL, #GRAY, #SILVER ainsi que #RED, #LIME, #YELLOW, #BLUE, #FUCHSIA, #AQUA, #WHITE. Cliquer @{"ici" LINK "Tutorial/Colors.iff/MAIN"} pour voir la synthèse de ces couleurs. @ENDNODE @NODE V6PrgDirectionCst "Guide Hollywood" @{APEN 16}@{b}Constantes directionnelle@{ub} @{APEN 1} Les constantes directionnelles sont utilisées par les commandes : @{"SetFontStyle()" LINK SetFontStyle} et @{"SetFormStyle()" LINK SetFormStyle} pour configurer le sens de l'ombre du texte ou d'objets graphiques. Il y a huit constantes directionnelles disponibles et elles correspondent à l'aiguille d'une boussole : #SHDWNORTH -> Nord #SHDWNORTHEAST -> Nord-Est #SHDWEAST -> Est #SHDWSOUTHEAST -> Sud-Est #SHDWSOUTH -> Sud #SHDWSOUTHWEST -> Sud-Ouest #SHDWWEST -> Ouest #SHDWNORTHWEST -> Nord-Ouest @ENDNODE @NODE V6PrgFormatTags "Guide Hollywood" @{APEN 16}@{b}Indicateurs de format@{ub} @{APEN 1} Depuis la version 2.5, Hollywood est en mesure de faire le formatage des textes à la volé (en temp réel). Les commandes @{"Print()" LINK Print}, @{"CreateTextObject()" LINK CreateTextObject}, et @{"TextOut()" LINK TextOut} supporte des formats tags spéciaux qui vous permettent de changer le style et la couleur des textes sans exécuter @{"SetFontStyle()" LINK SetFontStyle} ou @{"SetFontColor()" LINK SetFontColor}. Les indicateurs de format suivants sont actuellement disponibles : [b] : Changer le type de police en "gras". Utiliser [/b] pour annuler le type "gras". [I] : Changer le type de police en "italique". Utiliser [/i] pour annuler le type "italique". [u] : Changer le type de police en "souligné". Utiliser [/u] pour annuler le type "souligné". @{APEN 16} [shadow=,,]: @{APEN 1} Changer le style de police de caractère à "ombré". La nouvelle ombre utilisera alors la couleur spécifié dans . Elle sera affichée à une distance de pixel spécifié par l'argument et sera orienté selon une direction spécifié par . Veuillez utiliser l'une des 8 @{"constantes directionnelles" LINK V6PrgDirectionCst} dans l'argument . La couleur peut être en notation @{"RGB" LINK RGBInfo} ou en @{"ARGB" LINK ARGBInfo}. La transparence de l'ombre est totalement supportée. Utiliser [/shadow] afin d'annuler le style "Ombré" @{APEN 16} [edge=,]: @{APEN 1} Changer le style de police à "contouré". Ce style affichera un contour d'une épaisseur défini par autour du texte. Le contour peut être coloré par une couleur spécifié dans . Elle peut être une couleur spécifié en @{"RGB" LINK RGBInfo} ou en @{"ARGB" LINK ARGBInfo}. La transparence des contoures est totalement supportée. Utiliser [/edge] afin d'annuler le style "contouré". @{APEN 16} [color=]: @{APEN 1} Changer la couleur de la police en l'indiquant dans . La couleur peut être dans la notation @{"RGB" LINK RGBInfo} ou @{"ARGB" LINK ARGBInfo}. Si vous indiquez une valeur ARGB, le texte sera affiché avec de la transparence. Utiliser [/color] afin d'interrompre l'affichage dans la couleur et renvoi la couleur précédemment utilisé. Noter qu'en raison de ces indicateurs de format, vous devez utiliser deux parenthèses si vous voulez avoir une parenthèse dans votre texte. S'il y a seulement une parenthèse, Hollywood attendra toujours un indicateur de format. Voici un exemple de la façon dont vous pouvez utiliser ces indicateurs de format avec les commandes la bibliothèque texte : Print("Normal text [b]Bold text[/b] [i]Italic text[/i] [u]Underlined text[/u]") Comme vous pouvez le voir, utiliser des indicateur de format est réellement plus facile et le générateur de texte d'Hollywood est très puissant pour le formatage avancé des textes. @ENDNODE @NODE V6PrgLocal "Guide Hollywood" @{APEN 16}@{b}Déclaration Local@{ub} @{APEN 1} @{b}Local@{ub} [, , ...] [= [, , ...]] La commande local est utilisé pour indiquer à Hollywood que la variable spécifié devrait être locale. De plus, il peut également initialiser votre variable. Local myvar ; demander à Hollywood que myvar soit locale r = GetType(myvar) ; retourne #NIL DebugPrint(myvar) ; affiche 0 myvar = 5 ; maintenant myvar est créé comme une variable locale Le code ci-dessus indique simplement à Hollywood que myvar restera locale si une valeur lui est affecté. La déclaration "Local myvar" n'initialisera pas la variable. La variable sera toujours de type @{"Nil" LINK V6PrgTypeNil}, c.-à-d. : qu'elle ne devrait pas exister. myvar est créé quand vous la réglez avec une valeur particulière. Si la valeur initiale est différente de 0, vous ferez l'initialisation dans la déclaration locale, par exemple: Local myvar = 5 ; créer une variable locale Vous pouvez créer et initialiser autant de variables que vous le voulez. Utiliser juste une virgule de chaque côté des signes d'égalité. Exemple: Local myvar, myvar2, myvar3 = 5, 4, 3 Le code ci-dessus produit trois nouvelles variables locales et affecte la valeur 5 à myvar, 4 à myvar2 et 3 à myvar3. Noter que la déclaration locale ne doit pas être mis au début d'une fonction ou block comme c'est le cas avec des déclarations de variables dans d'autres langages de programmation. Vous pouvez les mettre la où vous le désirez et ce n'est en aucun cas une mauvaise méthode de programmation d'utiliser des variables Locales dans le milieu d'une fonction ou block. Par exemple, ce code est très bien : Block DebugPrint("Maintenant nous appelons TestFunc()") Local r = TestFunc() DebugPrint("Maintenant nous appelons TestFunc2()") Local r2 = TestFunc2() DebugPrint("Resultats:", r, r2) EndBlock Ce code utilise des variables locales dans le milieu d'un nouveau block et se n'est pas un problème pour Hollywood. Voir le chapitre @{"variables locales" LINK V6PrgLocals} pour plus d'information. @ENDNODE @NODE V6PrgLocals "Guide Hollywood" @{APEN 16}@{b}variables locale@{ub} @{APEN 1} Utiliser des variables locales chaque fois que nécessaire et dans la mesure du possible. Elles améliorent la gestion de la mémoire de votre programme parce que @{"le collecteur de données" LINK V6PrgGarbageCollector} sait automatiquement, quand il peut les effacer. De plus, l'accès aux variables locales est beaucoup plus rapide que les variables globales parce que Hollywood n'a pas besoin de contrôler l'environnement global et de plus, elles augmentent la lisibilité de votre programme. Les variables locales ont une vie limitée. Elles seront seulement disponible dans le block où vous les avez déclarées. Un block sera habituellement le corps d'une fonction mais il peut également être le corps d'une structure de contrôle. Vous pouvez même déclarer les blocks en utilisant les déclarations @{"Block ... EndBlock" LINK V6PrgBlock}. Important : Les variables locales doivent être déclarées de manière explicite. Si vous ne le faites pas, la variable sera automatiquement global. Par exemple, si vous écrivez: Function p_Add(a, b) tmp = a + b Return(tmp) EndFunction la variable "tmp" sera automatiquement créé comme variable globale. Mais c'est un gaspillage des ressources parce que vous avez besoin seulement de la variable à l'intérieur de la fonction, vous feriez mieux d'écrire: Function p_Add(a, b) Local tmp = a + b Return(tmp) EndFunction Maintenant la variable "tmp" est explicitement déclaré comme une variable locale et sera effacé quand la fonction P_Add() sera quitté. Les variables locales sont déclarées par l'utilisation de @{"déclaration Local" LINK V6PrgLocal}. Pour déclarer une variable locale, mettre simplement l'identificateur Local avant la déclaration : a = 10 ; variable globale Local b = 10 ; variable locale Si vous voulez initialiser plusieurs variables avec une déclaration local alors vous devrez utiliser simplement des virgules comme vous le feriez avec une attribution normal: a, b = 10, 5 ; variables globales! a reçoit 10, b reçoit 5 Local x, y = 10, 5 ; variables locales! x reçoit 10, y reçoit 5 Une fois que vous avez déclaré une variable locale, vous n'avez plus besoin d'utiliser Local plus longtemps : ; Si x > 10, On le multiplie par 2, sinon on le divise par 2 If x > 10 Local tmp = x ; declare une variable local "tmp" tmp = tmp * 2 ; multiplie la variable local "tmp" par 2 x = tmp ; assigne la valeur de la variable local "tmp" à "x" Else Local tmp = x ; declare la variable local "tmp" tmp = tmp / 2 ; divise la variable local "tmp" par 2 x = tmp ; assigne la valeur de la variable local "tmp" à "x" EndIf Print(tmp) ; affiche 0 parce que "tmp" n'est plus disponible Le code ci-dessus créé la variable locale "tmp" dans les deux blocks de la déclaration If. Ensuite il le multiplie ou le divise par 2. L'identificateur local n'est ici plus exigé parce que Hollywood sait déjà à ce momment que "tmp" est une variable locale. "tmp" sera effacé à la fin du block, il ne sera plus disponible dans la ligne "Print(tmp)". "tmp" deviendra @{"Nil" LINK V6PrgTypeNil} après les fins de block. Si vous n'affectez pas une valeur à la variable, elle obtiendrà la valeur @{"Nil" LINK V6PrgTypeNil} mais Hollywood saura que c'est une variable locale. Par exemple: If True ; se block est toujours lu Local x ; déclare la variable locale x Print(x) ; affiche 0 parceque x est Nil (NUL) x = 5 ; assigne 5 à la variable locale x Print(x) ; affiche 5 EndIf ; Fin du block et de la variable locale Print(x) ; affiche 0 puisque x est de nouveau Nil Vous pouvez également utiliser le nom d'une variable globale (ou d'une variable locale d'un block supérieure) pour une nouvelle variable locale. Par Exemple: a = 50 Block ; délimiter les deux prochaines lignes Local a = 40 ; créer une variable locale " a " et lui affecte 40 NPrint(a) ; affiche 40 EndBlock ; fin du block et de la variable a NPrint(a) ; affiche 50 Un exemple plus complexe qui utilise plusieurs variables avec le même nom: x = 10 ; global x (x1 = 10) Block ; ouvre un nouveau block Local x = x + 1 ; assigne 11 à la variable locale x (x2 = x1 + 1) Block ; ouvre un nouveau block Local x = x + 1 ; assigne 12 à la variable locale x (x3 = x2 + 1) Block ; ouvre un nouveau block Local x = x + 1 ; assigne 13 à la variable locale x (x4 = x3 + 1) EndBlock ; Fin du block x4 NPrint(x) ; prints 12 (= x3) EndBlock ; Fin du block x3 NPrint(x) ; prints 11 (= x2) EndBlock ; Fin du block x2 NPrint(x) ; prints 10 (= x0) Ce code pourrait être lu avec confusion mais il est sensé. Dans chaque nouveau block Hollywood va consulter la variable "x" à partir de la capacité et traversera tous les blocks supérieures. Il convient de noter que vous ne pouvez pas utiliser les variables locales avec @{"Gosub()" LINK Gosub} parce que Hollywood sautera du block actuelle sur @{"Gosub()" LINK Gosub} et le retournera plus tard avec des caractéristiques totalement différentes dans la pile. Ainsi, le code suivant ne fonctionnera pas : ; Code incorrect Block Local a = 50 ; création d'une variable locale "a" Gosub(SUBROUTINE) ; un saut en dehors du block; "a" peut être perdu Print(a) ; la valeur de la variable locale " a " est maintenant une certaine valeur faite au hasard de la valeur de la pile EndBlock Vous pouvez également utiliser des fonctions locales. Elles fonctionnent presque de la même facon et sont également préférable aux fonctions globales bien que vous ne pouvez pas les utiliser aussi souvent que vous utilisez les variables locales. Mais elles peuvent être utilisable de temps en temps. Voir le chapitre @{"fonctions locale" LINK V6PrgFuncLoc} pour plus d'informations sur ce sujet. @ENDNODE @NODE V6PrgGarbageCollector "Guide Hollywood" @{APEN 16}@{b}Collecteur de donnée@{ub} @{APEN 1} Hollywood invoquera son collecteur de donnée autant que cela sera nécessaire pendant que votre script est en exécution. Le collecteur de donnée manage toutes les ressources affectées par votre script et libère toute la mémoire qui n'est plus utilisé. Par Exemple: Print("Hello World") Après que Hollywood ait exécuté la commande @{"Print()" LINK Print}, la mémoire allouée pour la chaîne de caractères "Hello World" peut être effacé parce qu'elle n'est plus nécessaire. Vous pouvez aider le collecteur de donnée en réglant les variables à @{"Nil" LINK V6PrgTypeNil} quand vous n'en avez plus le besoin. C'est particulièrement utile pour de longues chaînes ou de grands tableaux, par exemple: a = {} For k = 1 To 1000 a[k] = {e1 = x, e2 = y} x = x + 5 y = y + 5 Next Ce code créé un tableau assez considérable qui occupe une certaine place mémoire dans votre système. Si vous n'avez plus besoin de ce tableau, il suffit simplement de le régler à @{"Nil" LINK V6PrgTypeNil}, par exemple: a = Nil Le collecteur de données libérera alors la mémoire occupée par ce tableau. Il est également fortement conseillé d'utilisiez des variables locales chaque fois que cela est possible parce que le collecteur de données peut automatiquement les effacer quand leur porté se termine (par exemple à la fin d'une fonction). Voir le chapitre @{"variables Locale" LINK V6PrgLocals} pour plus d'information. @ENDNODE @NODE V6PrgGlobal "Guide Hollywood" @{APEN 16}@{b}Déclaration Global@{ub} @{APEN 1} @{b}Global@{ub} [, , ...] [= [, , ...]] La déclaration globale est utilisé pour indiquer à Hollywood que la variable spécifié devrait être global. De plus, elle peut également initialiser votre variable. Cette déclaration est seulement inclue pour améliorer la lisibilité de votre programme. Vous pouvez également l'omettre et le script fonctionnera de la même façon. La déclaration global fonctionne exactement comme une @{"déclaration locale" LINK V6PrgLocal}. Si vous utilisez une déclaration globale, il est conseillé de placer toutes ces déclarations au début de votre code. Ainsi n'importe qui pourra ainsi lire clairement quelles variables est globalement disponible. Utilisé la déclaration globale ailleurs dans votre code n'est pas conseillé et peut être confondu à la lecture. Voir le chapitre @{"variables globale" LINK V6PrgGlobals} pour plus d'information. @ENDNODE @NODE V6PrgGlobals "Guide Hollywood" @{APEN 16}@{b}Variables Globales@{ub} @{APEN 1} Si vous affectez une valeur à une variable pour la première fois, alors cette variable deviendra automatiquement globale si vous ne la déclarez pas d'une manière explicite à Hollywood qu'elle sera locale par l'utilisation de la @{"déclaration locale" LINK V6PrgLocal}. Les variables globales peuvent être consulté n'importe où dans de votre script. Elles sont globalement utilisables pour toutes les commandes. Cependant, si il y a une variable locale q ui a le même nom qu'une variable globale, Hollywood l'utilisera toujours en priorité en tant que variable locale. Les variables globales sont plus lentes que les variables locales et elles ne sont pas facile à collectées par le @{"collecteur de données" LINK V6PrgGarbageCollector} à moins que vous l'indiquiez en utilisant @{"Nil" LINK V6PrgTypeNil} quand vous n'avez plus besoin. Ainsi, vous devrez seulement utiliser les variables globales quand c'est réellement nécessaire. Dans les fonctions vous devrez essayer de travailler avec des variables locales seulement. Voici un Exemple: ; mauvais code ! Function p_Add(a, b) tmp = a + b Return(tmp) EndFunction La variable tmp sera créé comme une variable globale. Ceci n'a pas beaucoup de sens ici parce que vous avez besoin seulement de la variable tmp dans cette fonction. Vous devrez la créer en local dans cette fonction, par exemple: ; bon code ! Function p_Add(a, b) Local tmp = a + b Return(tmp) EndFunction Pour améliorer la lisibilité de votre programme, vous pouvez utiliser @{"la déclaration Global" LINK V6PrgGlobal} pour repérer clairement certaines variables globales. C'est optionnel, parce que toutes les variables qui ne sont pas expressément déclarées en tant que variables locales, seront automatiquement globales. Mais l'utilisation de la déclaration globale rend votre programme plus lisible. Voir le chapitre @{"variables Locale" LINK V6PrgLocals} pour plus d'information. @ENDNODE @NODE V6PrgVariables "Guide Hollywood" @{APEN 16}@{b}Variables et constantes@{ub} @{APEN 1} Une variable peut être utilisée pour enregistrer une partie de données sous un nom donné. Dans Hollywood, les variables ne doivent pas être déclarés. Cela signifie que vous pouvez affecter simplement une valeur à une variable sans devoir définir son type auparavant. Hollywood le fera automatiquement. Le nom de votre variable doit débuter par un caractère de l'alphabet (a-z) ou un soulignage (_). Après le premier caractère, vous pouvez également utiliser des nombres, le point d'exclamation (!) et le symbole dollar ($). Il est suggéré d'utiliser le symbole dollar seulement dans les variables du type chaîne. Comme Hollywood est un langage peu sensible, tous les noms de variable ne sont pas distingué par les majuscules et minuscules. Cela signifie que, par exemple, les noms " MYVAR " et " myvar " se rapportent à la même variable. Hollywood est un langage opérant sur des objets de types déterminés dynamiquement, cela signifie que les variables sont également dynamiques. Par exemple, ce qui suit fonctionne sans problèmes: myvar = 1.5 myvar = "Hello" myvar = {1, 2, 3} myvar = Function DebugPrint EndFunction Vous pouvez changer le type d'une variable à la volé (en temp réel). Mais ce n'est pas une bonne pratique de programmation. Les constantes sont des valeurs fixes qui sont globalement disponible depuis n'importe où dans votre script. Elles sont préfixées avec un caractère d'informations (#) de sorte que vous puissiez les discerner des variables et des fonctions. @ENDNODE @NODE V6PrgStyleguideSuggestions "Guide Hollywood" @{APEN 16}@{b}Suggestions de programmation@{ub} @{APEN 1} Voici quelques suggestions pour maintenir votre code lisible. Comme vous avez pu lire auparavant, Hollywood ne distingue pas les lettres majuscules des lettres minuscules mais pour maintenir vo tre code lisible, je vous propose les régles suivantes sur l'architecture d'un programme : - Ecrire les commandes comme elles apparaissent dans cette documentation au moins les commencer par des lettres majuscules - Ecrire les constantes en lettre majuscule pour les discerner des noms de variable - Ecrire toutes les commandes préprocesseur en capitales afin de les mettre en valeur - une commande par ligne est suffisante! - Utiliser le caractére " $ " seulement dans des variables chaîne de caractères - Utiliser le caractére " ! " seulement dans les variables qui contiennent des valeurs à virgules flottantes - quelques commentaires afin de se repérer - Quand vous utilisez des blocs et des boucles, utiliser des tabulations pour structurer les différents niveaux (indentation) - Vous devriez préfixer vos propres fonctions avec "p_" pour les distinguer des fonctions Hollywood (il pourrait y avoir des fonctions Hollywood dans de future versions qui auront le même nom que vos fonctions, se qui pourrait entraîner des résultats inattendus) @ENDNODE @NODE V6PrgIncludes "Guide Hollywood" @{APEN 16}@{b}Includes@{ub} @{APEN 1} Les includes peuvent être utilisé pour importer des codes dans un fichier séparé vers votre Script principale. Vous pouvez importer des scripts Hollywood (fichiers .hws) aussi bien que des @{"applets Hollywood" LINK Applets}(fichier .hwa). Les programmes que vous importez sous forme de fichiers .hws/.hwa seront incorporés dans votre programme principale de sorte que ces fichiers ne soient pas requis lors de la compilation. L'importation de code est particulièrement utile pour de grands projets car un programme peut facilement devenir trés complexe à relire et comprendre si vous avez seulement un fichier de codes sources avec un nombre imortant de ligne de code. L'idée d'inclure les fichiers est de couper votre programme en plusieurs partie. Par exemple, un jeu de plate forme peut être découpé en plusieurs partie comme l'introduction, le menu, le moteur de niveau, les niveaux et le jeu en lui même. Maintenant vous créez les fichiers de codes sources pour chaque partie, par exemple Intro.hws, Menu.hws, MapEngine.hws, Level.hws et Game.hws. Un des fichiers codes sources doit contenir les codes sources principaux, se sera ses codes sources que vous exécuterez avec Hollywood. L'autre méthode est que l'on peut créer des bibliothéques Hollywood sous forme d'Applet. Vous pourriez alors publier ces applets de sorte que les autre programmeurs puissent en tirer partie en important ces applet dans leurs propres projets de programme. L'avantage de distribuer votre bibliothéque comme applet est que les codes sources de votre bibliothéque ne sont pas lisibles par les autres utilisateurs/programmeurs. les applet Hollywood contiennent seulement le code pré compilé qui n'est pas compréhensible par l'utilisateur. Ainsi si vous voulez protéger votre code mais que vous voulez le partager avec d'autres utilisateurs, vous devez simplement le distribuer comme applet Hollywood. Nous allons retourner à notre exemple d'un jeu vidéo qui à son code dispatché dans plusieurs fichier. Nous supposons qu'Intro.hws sera notre code source principal puisque l'introduction est le premier éléments à exécuter, et c'est cela que l'utilisateur verra en premier. L'en-tête de notre fichier source Intro.hws ressemblera à se qui suit : @INCLUDE "Menu.hws" @INCLUDE "MapEngine.hws" @INCLUDE "Level.hws" @INCLUDE "Game.hws" ShowIntro() ShowMenu() ; Function ShowMenu() declared in Menu.hws RunGame() ; RunGame() declared in Game.hws DrawMap() ; DrawMap() declared in MapEngine.hws NextLevel() ; NextLevel() declared in Level.hws Vous remarquez que nous utilisons la commande pré processeur @{"@INCLUDE" LINK atINCLUDE} afin d'insérer quatre fichiers source dans notre fichier principale Intro.hws. Ceci vous permet d'appeler toutes les fonctions qui sont déclarés dans ces quatre fichiers dans le codes sources principale, c.-à-d. du fichier Intro.hws. Dans la plupart des cas les fichiers includes contiennent seulement des fonctions, variables ou contantes. Si il y a des commandes d'exécutions immédiates dans vos fichiers d'inclusion, par exemple DebugPrint("bonjour"), ils seront exécuté avant n'importe quel autre code de votre programme principale puisque tout les fichiers Include sont insérés et exécuter dans l'ordre qu'ils ont été alloué. Dans notre exemple d'avant, Hollywood ouvrirait Menu.hws et insérerait son code en premier, puis MapEngine.hws. Puis Level.hws et finalement Game.hws. Ainsi le programme Hollywood compilé ressemblerait à ce qui suit : @INCLUDE "Menu.hws" @INCLUDE "MapEngine.hws" @INCLUDE "Level.hws" @INCLUDE "Game.hws" < contenu du fichier Menu.hws > < contenu du fichier MapEngine.hws > < contenu du fichier Level.hws > < contenu du fichier Game.hws > ShowIntro() ShowMenu() Vous voyez que tout les fichiers Include sont insérés avant la partie de code de votre programme principal. Par conséquent toutes les commandes des includes seront exécuté avant le code du codes sources principal. Si vous voulez inclure des applet, il faut simplement lancer un fichier d'applet avec la commande préprocesseur @INCLUDE: @INCLUDE "My_Cool_Library.hwa" ; importation de la fonction My_Cool_Library.hwa MyCoolLib_Func(); appel de la fonction MyCoolLib_Func() qui a été défini dans le fichier My_Cool_Library.hwa @ENDNODE @NODE V6PrgComments "Guide Hollywood" @{APEN 16}@{b}Les Commentaires@{ub} @{APEN 1} Hollywood supporte deux types de commentaires : Par une terminaison de saut de ligne et par une terminaison manuel du commentaire par le programmeur. Le début de commentaire par terminaison de saut de ligne débute si Hollywood découvre un point-virgule dans votre code. Hollywood ignorera tous se qui suit ce point-virgule et continuera d'analyser le code dans la prochaine ligne. Par Exemple: DebugPrint("bonjour") ; Salut je suis un commentaire par saut de ligne ! Dans la deuxième version, le programmeur doit déclarer la fin du commentaire. Vous commencez votre commentaire avec la séquence de caractéres /* et la finissez avec */. Puisque ce commentaire est terminer par le programmeur, il peut être utilisé sur plusieurs lignes. Mais il peut être également en milieu ou au début d'une ligne. Exemples : /* Tout se qui est écrit ici sera ignoré par Hollywood ! /* DebugPrint("bonjour")/* bonjour je suis un commentaire */ DebugPrint("tout le monde") Important: commenter votre code. Vous ne devez pas commenter chaque variable local mais donner une description courte des fonctions, cela permet une meilleur lecture ainsi qu'une meilleur compréhension de vos programmes. @ENDNODE @NODE V6PrgStrNumConv "Guide Hollywood" @{APEN 16}@{b}Conversion de chaîne et de nombre @{ub} @{APEN 1} Hollywood supporte la conversion automatique de chaîne en nombre et inversement des nombres en chaîne. Cela signifie que si une fonction attend une chaîne dans un argument et que vous obtenez un nombre, alors Hollywood convertira automatiquement se nombre en une chaîne de et la rendra compatible avec la fonction comme une chaîne. Par Exemple: @{"StrLen()" LINK StrLen} renvoie la longueur de la chaîne de caractères. Maintenant si nous appelons a = StrLen(256) Hollywood convertira automatiquement le nombre 256 en chaîne "256" et pour cette raison la variable a reçu la valeur de 3 parce que la chaîne de caractères "256" se compose de trois caractères. Cela fonctionne de la même façon dans le sens inverse. Si vous obtenez une chaîne dans une fonction alors qu'elle s'attend à un nombre, alors Hollywood essayera de convertir cette chaîne en un nombre. La différence de conversion de nombre à chaîne est que la conversion pourrait être erroné. Par exemple: Hollywood ne peut pas convertir une chaîne comme "bonjour" en nombre. La chaîne de doit contenir des chiffres décimaux ou hexadécimaux. Les chaînes avec un mélange alphabétiques et numérique ne peuvent pas être converti que se soit dans un sens comme dans l'autre, même si les chiffres apparaissent avant les caractères. Les nombres hexadécimaux doivent être préfixés avec le symbole dollar ($) ou 0x. Exemple: LoadBrush("1", "Ram:Brush.iff") @{"LoadBrush()" LINK LoadBrush} s'attend à un nombre comme identificateur. Ainsi, la chaîne "1" est automatiquement converti en nombre par Hollywood. Ceci en revanche ne fonctionne pas: LoadBrush("Test", "Ram:Brush.iff") LoadBrush("1Test", "Ram:Brush.iff") Les chaînes de caractères "Test" ou "1Test" ne peuvent pas être converties en nombre. Vous pouvez également utiliser tous les opérateurs avec des nombres et des chaînes de exceptés les opérateurs relationnels. Ils peuvent seulement comparer deux valeurs de mêmes types de données. Par exemple, le code suivant fonctionne très bien : a = "5" * 10 + 100 / "10" + ("100" - 60) ; a égale 100 Mais ce code retournera une erreur puisque vous utilisez des opérateurs relationnels avec des valeurs de types différents : If "10" < 20 ---> erreur! Si vous voulez effectuer se genre d'opération, vous devez utiliser @{"Val()" LINK Val} ou @{"StrStr()" LINK StrStr} pour convertir le nombre manuellement en chaîne de caractères ou une chaîne de caractères en nombre. Par exemple: If Val("10") < 20 ---> Fonctionne! @ENDNODE @NODE V6PrgDo "Guide Hollywood" @{APEN 16}@{b}Do@{ub} @{APEN 1} La boucle DO est utilisé dans les versions courtes de @{"While-Wend" LINK V6PrgWhile} et de @{"For-Next" LINK V6PrgFor}. @ENDNODE @NODE V6PrgTrueFalse "Guide Hollywood" @{APEN 16}@{b}True and False@{ub} @{APEN 1} True et False sont des constantes incorporées qui ont les valeurs 1(True) et 0(False). @ENDNODE @NODE V6PrgReserved "Guide Hollywood" @{APEN 16}@{b}Reservé pour une future utilisation@{ub} @{APEN 4} Cette partie est réservé pour un usage futur. @{APEN 1} @ENDNODE @NODE V6PrgIdentifiers "Guide Hollywood" @{APEN 16}@{b}Identifiants réservés@{ub} @{APEN 1} Les identifiants suivants sont réservés par Hollywood et ne peuvent pas être utilisé comme noms de variable ou de fonction : @{"And " LINK V6PrgOprLogic} @{"Block " LINK V6PrgBlock} @{"Break " LINK V6PrgBreak} @{"Case " LINK V6PrgSwitch} @{"Const " LINK V6PrgConst} @{"Continue " LINK V6PrgContinue} @{"Default " LINK V6PrgSwitch} @{"Dim " LINK V6PrgDim} @{"DimStr " LINK V6PrgDim} @{"Do " LINK V6PrgDo} @{"Else " LINK V6PrgIf} @{"ElseIf " LINK V6PrgIf} @{"EndBlock " LINK V6PrgBlock} @{"EndFunction " LINK V6PrgFunctions} @{"EndIf " LINK V6PrgIf} @{"EndSwitch " LINK V6PrgSwitch} @{"False " LINK V6PrgTrueFalse} @{"For " LINK V6PrgFor} @{"Forever " LINK V6PrgRepeat} @{"Function " LINK V6PrgFunctions} @{"Global " LINK V6PrgGlobal} @{"Gosub " LINK Gosub} @{"Goto " LINK Goto} @{"If " LINK V6PrgIf} @{"In " LINK V6PrgReserved} @{"Label " LINK Label} @{"Local " LINK V6PrgLocal} @{"Next " LINK V6PrgFor} @{"Nil " LINK V6PrgTypeNil} @{"Not " LINK V6PrgOprLogic} @{"Or " LINK V6PrgOprLogic} @{"Repeat " LINK V6PrgRepeat} @{"Return " LINK V6PrgReturn} @{"Step " LINK V6PrgFor} @{"Switch " LINK V6PrgSwitch} @{"Then " LINK V6PrgIf} @{"To " LINK V6PrgFor} @{"True " LINK V6PrgTrueFalse} @{"Until " LINK V6PrgRepeat} @{"Wend " LINK V6PrgWhile} @{"While " LINK V6PrgWhile} @{"Xor " LINK V6PrgReserved} Si vous essayez d'utiliser un de ces identifiants comme fonction ou nom de variable vous obtiendrez une erreur. @ENDNODE @NODE V6PrgIntroduction "Guide Hollywood" @{APEN 16}@{b}Premier pas@{ub} @{APEN 1} Le langage script Hollywood est facile à utiliser et très puissant. La syntaxe est basé principalement sur le BASIC mais Hollywood est beaucoup plus puissant puisqu'il est un langage opérant sur des objets de types déterminés dynamiquement. Nous expliquerons plus tard ce que cela signifie pour le programmeur. Hollywood est composé des meilleurs éléments du (Blitz) BASIC, du C, AmigaE, Pascal et Lua, le tout dans un langage puissant, souple, avec lequel vous pouvez créer presque tout avec peu d'effort. Les script Hollywood sont juste des fichiers ASCII Ordinaires.Ainsi vous pouvez utiliser n'importe quel éditeur selon vos habitudes. Voici comment écrire le fameux programme "Hello World!" avec Hollywood : Print("Hello World!") WaitLeftMouse() End() Le petit programme ci-dessus ouvrira un écran de 640x480. Si vous voulez qu'Hollywood ouvre un écran avec d'autres dimension, vous devrez utiliser les commandes préprocesseurs @{"@DISPLAY" LINK atDISPLAY} ou @{"@BGPIC" LINK atBGPIC}. 640x480 est la taille d'affichage par défaut qu'Hollywood utilise lorsque vous n'apporter pas de spécifications. Les tailles d'affichage ne sont pas les mêmes que les résolutions d'écran. C'est juste la taille de votre affichage (votre zone de travail!). Les tailles d'écran peuvent être plus grandes que la taille d'affichage. Votre affichage sera centré sur l'écran (vous pouvez utiliser la commande préprocesseur @{"@DISPLAY" LINK atDISPLAY} si vous voulez une position d'affichage initiale différente). La fenêtre qui est ouverte peut être plus grandes que votre taille d'écran si elle a des bords. Si vous indiquez l'argument @{"BORDERLESS" LINK ManualUsage}, la taille de la fenêtre sera identique à votre taille d'écran. Si vous voulez avoir une image de fond au lieu d'un fond d'écran noir, insérer juste la commande pré processeur @{"@BGPIC" LINK atBGPIC} au début de votre script: @BGPIC 1, "FancyBackground.jpg" Print("Hello World!") WaitLeftMouse() End() Vous pouvez également mettre de multiples commandes sur une ligne, ainsi le code ci-dessus pourrait également être écrit comme ceci : Print("Hello World!") WaitLeftMouse() End() Cependant, il est plus judicieux d'utiliser la structure de code avec des retours à la ligne afin d'obtenir une meilleure lisibilité. Pour finaliser votre code, vous pouvez également utiliser des commentaires commençant par un " /* " et finir avec " */ " ou juste un commentaire avec " ; ", par Exemple: /* ceci est un commentaire /* Print("Hello World!") ; celui-ci aussi WaitLeftMouse() ; Attente la souris gauche End() ; Sortie Si une fonction Hollywood n'accepte ou ne retourne aucun argument, vous pouvez omettre les parenthèses quand vous appelez la fonction. Cependant, si vous obtenez des arguments d'une fonction ou si vous voulez enregistrer la valeur de renvoi d'une fonction, vous devez utiliser des parenthèses. Dans notre exemple, nous pourrions omettre les parenthèses pour les commandes @{"WaitLeftMouse()" LINK WaitLeftMouse} et @{"End()" LINK End} puisqu'elles ne prennent aucun argument: Print("Hello World!") WaitLeftMouse End Naturellement, il est également possible d'utiliser des variables au lieu de nombres directs ou de chaînes. Vous n'avez pas besoin de déclarer les variables et elles sont initialisé à zéro ou par une chaîne vide selon son type quand vous les utilisez la première fois. Les variables sont soit écrit avec une lettre de A/a à Z/z ou un soulignage. Elles peuvent également contenir des numéros de 0 à 9, le symbole dollar ($) et le point d'exclamation (!). C'est une question de style, les variables qui contiennent des chaînes devraient avoir un symbole $ comme derniers caractère et les variables qui contiennent des valeurs à virgules devraient avoir un point d'exclamation comme dernier caractère. Ceci rend vos scripts plus lisible. La longueur d'un nom de variable ne doit pas dépasser 64 caractères. mystring$ = "Hello World!" Print(mystring$) WaitLeftMouse End A part les commandes normales, il y a également des commandes préprocesseur disponible avec Hollywood. Ces commandes sont traitées en priorité, donc avant l'exécution du script et elles sont toujours préfixées avec un caractère @ (arobase). Une de ces commandes préprocesseur est @{"@VERSION" LINK atVERSION}, elle vous permet de définir la version minimal d'Hollywood exigé pour que votre programme soit exécuté. Par exemple, le code suivant fonctionnera uniquement avec les versions Hollywood 2.0 et supérieur : @VERSION 2.0 Print("Hello World!") WaitLeftMouse End Vous devriez toujours utiliser cette commande pré processeur comme première action de votre script pour vous assurer que la version est vérifiée avant toute autre chose. Si vous écrivez le code ci-dessus avec votre éditeur de texte et que vous le sauvegardez en MyScript.hws, vous pouvez alors l'exécuter d'une console en tapant: 1> Hollywood MyScript.hws [ARGUMENTS] [ARGUMENTS] peuvent être @{"les arguments Hollywood" LINK ManualUsage}. Si vous voulez exécuter votre script par le GUI, l'ouvrir, cliquer sur "Display" et choisir votre script. félicitations, vous avez créé votre premier code compatible Hollywood. @ENDNODE @NODE V6PrgTypeIntro "Guide Hollywood" @{b}Types de données@{ub} Ce chapitre indique tous les types de données disponibles avec Hollywood. Les cinq types de données suivant sont disponible : @{"Number " LINK V6PrgTypeNumber} les valeurs numériques comme 1, 2, $FF, 3.5, 1.7e8, True, False, 'a' @{"String " LINK V6PrgTypeString} séquences de caractères; habituellement utilisé pour le texte par exemple "bonjour" @{"Table " LINK V6PrgTypeTable} collection de données de même ou différents types @{"Function " LINK V6PrgTypeFunc} sous-programmes exécutable par l'utilisateur @{"Nil " LINK V6PrgTypeNil} signifie qu'une variable n'a aucune valeur Vous pouvez trouver le type de donnée d'une variable en utilisant la commande @{"GetType()" LINK GetType}. Par exemple: GetType(1) ---> retourne #NUMBER GetType(2.5) ---> retourne #NUMBER GetType(True) ---> retourne #NUMBER GetType('x') ---> retourne #NUMBER GetType(#STRING) ---> retourne #NUMBER GetType("qui suis-je ?") ---> retourne #STRING GetType({1, 2, 3}) ---> retourne #TABLE GetType(DebugPrint) ---> retourne #FUNCTION GetType(zéro) ---> retourne #NIL @ENDNODE @NODE V6PrgTypeNil "Guide Hollywood" @{b}Nil@{ub} Si vous utilisez une variable sans lui affecter de valeur, la variable sera du type Nil, se qui signifie que la variable n'existe pas. Hollywood utilise seulement les variables qui ont une valeur. Si vous utilisez une variable qui n'est pas initialisé dans une fonction ou avec un opérateur, la varibale sera automatiquement converti à zéro ou si la fonction attend une chaîne par une chaîne vide (""). Si vous n'avez plus besoin d'une variable, vous pouvez également la régler à Nil et elle sera effacé alors dans le prochain cycle du @{"collecteur de données" LINK V6PrgGarbageCollector}. Vous pouvez également effacer un élément d'un tableau en le réglant à Nil. Attention en vérifiant des variables qui sont égal à Nil parce que 0=Nil est vrai dans Hollywood. @{"GetType()" LINK GetType} est la seule méthode fiable pour découvrir si la variable est réellement à Nil. Vérifier simplement si elle est encore à Nil donnerait également le résultat True si la variable était égal à 0. @ENDNODE @NODE V6PrgTypeFunc "Guide Hollywood" @{b}Functions@{ub} Les fonctions sont également dans notre chapitre types de données. Dans Hollywood, chaque fonction est une variable. Cela signifie que vous pouvez les initialiser comme des variables, vous pouvez utiliser des fonctions comme paramètres à d'autres fonctions et des fonctions peuvent également être des valeurs de renvoi pour d'autre fonctions. Par exemple, le code suivant: p_Print = Function DebugPrint EndFunction est une autre méthode pour écrire : Function p_Print DebugPrint EndFunction Puisque les fonctions sont des variables, vous pouvez également leurs affecter de nouvelles valeurs, par Exemple: DebugPrint = Print Maintenant tous les appels à la fonction @{"DebugPrint()" LINK DebugPrint} appelleront la commande @{"Print()" LINK Print} à la place. Il y a bien plus à savoir sur la fonction type de données. Et c'est cela qu'il a son propre chapitre dans ce manuel. Cliquer @{"ici" LINK V6PrgFunctions} pour afficher le chapitre sur les fonctions. @ENDNODE @NODE V6PrgDim "Guide Hollywood" @{b}Dim and DimStr@{ub} @{b}Dim@{ub} @{b}[@{ub}@{b}]@{ub} ([], ...), ... @{b}DimStr@{ub} @{b}[@{ub}@{b}]@{ub} ([], ...), ... Les déclarations Dim et DimStr peuvent être utilisés pour créer un tableau n dimensionnel avec des tailles spécifiés et initialiser tous ses éléments à 0 (Dim) ou "" (DimStr). Lire la documentation sur le @{"type de données tableau" LINK V6PrgTypeTable}, Les indicateurs du tableau doivent être initialisés avant d'être utilisés. Même si un indicateur est seulement un zéro ou une chaîne vide, vous devez l'initialiser avec cette valeur avant de l'utiliser. La déclaration Dim peut vous aider ici. Il créra le tableau spécifié par avec la taille spécifié par . Le paramètre doit être une constante, pas une variable. Noter, que spécifie la taille réelle du tableau et pas le dernier élément qui doit être initialisé. Donc, si vous utilisez 50 dans , Hollywood initialisera les cellules du tableau de 0 à 49. La cellule 50 du Tableau ne sera pas initialisé. Voici un Exemple: Dim mytable[100] Cette déclaration peut être traduit avec le code suivant : Local mytable = {} For k = 0 To 99 Do mytable[k] = 0 La déclaration Dim devient réellement maniable si vous voulez créer des tableaux multidimensionnel. Vous pouvez utiliser autant de crochets que vous le désirez après la spécification . Chaque nouveau crochet créra un nouveau tableau de la taille spécifié. Par Exemple: Dim vector[10][10][10] La déclaration ci-dessus créé un tableau de vecteur tridimensionnel et initialise tous à zéros. Cette déclaration traduite par la suite, devient un peu plus complexe, code Hollywood : Local vector = {} For i = 0 To 9 vector[i] = {} For j = 0 To 9 vector[i][j] = {} For k = 0 To 9 vector[i][j][k] = 0 Next Next Next Vous pouvez également créer et initialiser plus d'un tableau avec cette déclaration. Utiliser juste une virgule après la dernière spécification et vous pouvez répéter la procédure complète autant de fois que vous le désirez. Exemple: Dim table1[50], table2[50], table3[50] La déclaration DimStr fonctionne de la même manière que Dim mais initialise tous indicateurs avec des chaînes vides (""). Noter que Dim/DimStr créra toujours des tableaux locaux si vous êtes pas dans le bloc principale de votre script. Ainsi si vous voulez qu'un tableau soit global vous devez être sÃ"r d'utiliser le rapport Dim/DimStr dans le bloc principale du script. Garder également à l'esprit que Dim/DimStr ne limite pas le tableau à la taille spécifié. Le tableau peut se développer parce que Hollywood est un langage dynamique. Pour développer un tableau, initialiser simplement les indicateurs que vous avez besoin et Hollywood le développera automatiquement. Par exemple: Dim table[50] For k = 50 To 59 Do table[k] = 0; augmente le tableau de 10 indicateurs supplémentaires Le code ci-dessus créé un tableau avec espace de 50 indicateurs et l'augmente à 60 indicateurs. Si vous voulez rétrécir un tableau, régler l'indicateur correspondant à @{"Nil" LINK V6PrgTypeNil}. Par exemple: Dim table[50] For k = 40 To 49 Do table[k] = Nil ; Le tableau est imputé de 10 indicateurs Le code ci-dessus diminue le tableau initialisé à 50 indicateurs à 40 indicateurs initialisés. Hollywood est un langage opérant dynamiquement sur des objets de types déterminés dans lequel les tableaux n'ont pas une taille fixe. Vous pouvez augmenter et diminuer vos tableaux en rapport à vos besoin. @ENDNODE @NODE V6PrgTypeTable "Guide Hollywood" @{b}Tableau@{ub} Un tableau est une collection de différentes données élémentaires qui peuvent être de différent type. Un tableau est la structure de données universelle à Hollywood. Il peut être utilisé sous différentes formes, par exemple comme choix comme liste ou comme enregistrement. Les tableaux sont créés en utisilant la construction {}. Par exemple, Le code suivant créé un tableau vide: a = {} Un tableau vide est inutile parce qu'il n'y a aucune données et Hollywood exige que tous les indicateurs d'un tableau soient initialisés avant d'être utilisé . Si vous essayez d'accéder à un indicateur de ce tableau vide en indiquant par exemple b = a [0] vous obtiendriez une erreur déclarant que cet indicateur 0 n'a pas été initialisé. Vous pouvez seulement accéder aux indicateurs du tableau qui ont été précédement initialisé. Le code correcte serait: a [0] = 5 ; affecter 5 à a [0] b = a [0] ; affecter 5 à b Ou vous pouvez également utiliser la construction {} pour initialiser le tableau: a = {5} ; créer un tableau avec 5 comme élément 0 b = a [0] ; affecter 5 à b Vous pouvez également utiliser la construction {} pour initialiser le tableau avec plusieurs indicateurs. La construction {} affecte les valeurs spécifié dans un tableau en démarrant à l'index 0. Par Exemple: a = {1, 2, 4, 8, 16, 32, 64, 128, 256} ; créer un tableau avec 9 éléments b = a [7] ; affecter 128 à b (128 est à l'index 7 en a) De plus, vous pouvez utiliser les @{"déclarations Dim et DimStr" LINK V6PrgDim} pour créer et initialiser un tableau d'une taille spécifiée. Hollywood, les index peuvent non seulement être des nombres entiers positifs mais également des nombres entiers négatif, des valeurs virgules flottantes et même des chaînes de caractères. Par exemple, vous pouvez également initialiser les éléments négatifs dans un tableau : a = {} ; créer un tableau vide a [- 5] = 3 ; affecter 3 à l'index -5 a [1.5] = 2 ; affecter 2 à l'index 1.5 Si vous voulez effectuer une initialisation avec la construction {}, vous devez utiliser des crochets. Les trois lignes ci-dessus auraient pu également être écrite ainsi: a = {[- 5] = 3, [1.5] = 2} ; initialiser un nouveau tableau Si vous voulez utiliser des chaînes comme index, vous pouvez utiliser les déclarations suivantes : a = {} ; créer un tableau vide a["nom"] = "John Doe" ; affecter "John Doe" à l'index "nom" a["age"] = 20 ; affecter "20" à l'index "age" a["sexe"] = "homme" ; affecter "homme" à l'index "sexe" Une méthode plus simple d'utiliser des chaînes comme index est d'utiliser l'expression ".". Le code suivant fait la même chose que le code ci-dessus: a = {} ; créer un tableau vide a.name = "John Doe" ; affecter "John Doe" à l'index "nom" a.age = 20 ; affecter "20" à l'index "age" a.sex = "homme" ; affecter "homme" à l'index "sexe" Enfin, vous pouvez également utiliser la construction {} pour initialiser un tableau avec des index nommés. le code suivant fait la même chose que les deux extraits du dessus: a = {["nom"] = "John Doe", ["age"] = 20, ["sexe"] = "homme"} Ou plus simple: a = {nom = "John Doe", age = 20, sexe = "homme"} Vous pouvez accéder à des éléments nommés d'un tableau avec ces 2 façons: b = a["nom"] b = a.nom Les deux lignes affecteront la même valeur à b. La méthode la plus courante pour accéder et initialiser des éléments nommés d'un tableau est d'utiliser la méthode ".". Noter que Hollywood ne distingue pas les majuscules des minuscules, ainsi vous pouvez également accéder aux éléments ci-dessus en utilisant a.NOM ou même a.nOm. Vous pouvez ajouter des éléments à un tableau en leur affectant simplement une valeur. Si vous voulez retirer des éléments, vous devez régler leur valeur à @{"Nil" LINK V6PrgTypeNil}. C'est un autre avantage du langage de programmation Hollywood qui est dynamique. Des Tableaux ne sont pas limités à une taille particulière: Vous pouvez les développer et les rétrécir à votre convenance. @{b}Exemples plus complexes@{ub} Vous pouvez également utiliser les tableaux qui combinent des éléments nommés et numérotés, exemple: a = {x = 100, y = 50, 10, 11, 12, 13, z = 30, [6] = 16, 14, 15, obj = "Cube"} Ceci créé un nouveau tableau et initialise les éléments de 0 à 6 avec les nombres de 10 à 16. De plus, il créé quatre éléments nommés x, y, z et obj et les initialise à 100, 50, 30 et "Cube". --------------------------------------------------------------------------------- Il est également possible d'utiliser des tableaux dans des tableaux. Exemple: boutons = { {x1 = 0, y1 = 0, x2 = 100, y2 = 50}, {x1 = 100, y1 = 0, x2 = 80, y2 = 50}, {x1 = 180, y1 = 0, x2 = 100, y2 = 50} } Le code créé un noueau tableau appelé "boutons" et initialise les trois premiers éléments avec des tableaux qui contiennent la position de début et de fin de chaque bouton. Nous pouvons maintenant utiliser le code suivant pour créer ces trois boutons: For k = 0 To 2 CreateButton(k + 1, boutons[k].x1, boutons[k].y1, boutons[k].x2, boutons[k].y2) Next --------------------------------------------------------------------------------- Les tableaux multidimensionnels sont également gérés. le code suivant créé une matrice de la taille 50x100 et l'initialise à zéro : N = 50 M = 100 mtx = {} ; créer un tableau vide For i = 0 To N - 1 mtx [I] = {} ; créer une nouvelle colonne For j = 0 To M - 1 mtx [I] [j] = 0 ; initialiser l'élément Next Next Vous pouvez également utiliser les @{"déclarations Dim et DimStr" LINK V6PrgDim} pour créer des tableaux multidimensionnels. --------------------------------------------------------------------------------- Vous ne devez pas utiliser de constantes quand vous initialisez un tableau en utilisant la construction {}. Vous pouvez utiliser des variables où vous voulez. Par exemple: s$ = "test" i = 5 a = {[s$] = "Un élément", [i * 5 + 1] = "Un autre élément"} Ce code créra l'élément a.test (qui est identique à a["test"]) et lui affectera la chaîne "Un élément". De plus, il créé l'élément a[26] et lui affecte la chaîne "Un autre élément". --------------------------------------------------------------------------------- Ne soyez etonné quand vous lisez quelque chose de semblable à: x = 5 y = 4 a = {x = x, y = y} ; affecter 5 dans "x" et 4 dans "y" La déclaration de tableau ci-dessus censé. Elle créait un tableau avec deux éléments nommé "x" et "y". L'élément "x" obtient la valeur de la variable x qui est 5 et l'élément "y" obtient la valeur de la variable y qui est 4. Une autre méthode d'écrire le code ci-dessus serait par exemple: x = 5 y = 4 a = {} ; tableau vide a.x = x ; affecter 5 à a.x a.y = y ; affecter 4 à a.y Les deux extraits effectue la même chose. --------------------------------------------------------------------------------- Vous pouvez mettre des fonctions dans vos tableaux. Voici un Exemple: a = {Add = Function(v1, v2) Return(v1 + v2) EndFunction, ShowBrush = DisplayBrush} a.ShowBrush(1, #CENTER, #CENTER) ; appel DisplayBrush (1, #CENTER, #CENTER) b = a.Add(15, 16) ; renvois 31 dans b le code ci-dessus créé un tableau avec deux fonctions. La première fonction est une fonction qui ajoute deux valeurs et la deuxième fonction se référe simplement à la commande Hollywood @{"DisplayBrush()" LINK DisplayBrush}. Vous pouvez également écrire ce code de la façon suivante: a = {["Add"] = Function(v1, v2) Return(v1 + v2) EndFunction, ["ShowBrush"] = DisplayBrush} a["ShowBrush"](1, #CENTER, #CENTER) ; appel DisplayBrush(1, #CENTER, #CENTER) b = a["Add"](15, 16) ; renvois 31 à b @ENDNODE @NODE V6PrgTypeString "Guide Hollywood" @{b}Chaîne@{ub} Le type chaîne peut être utilisé pour enregistrer une séquence de caractères. Hollywood utilise 8 bits (un octet) pour chaque caractère. Les chaînes sont spécifiées par l'utilisation des guillemets. C'est une question de style, vous devez toujours suffixer une variable chaîne avec le symbole dollar $ de sorte qu'un lecteur de votre code puisse voir facilement quelles variables transportent des chaînes et/ou des nombres. Par exemple: a$ = "Hello World!" On peut également l'écrire ainsi: a = "Hello World!" Mais avec le symbole dollar à l'extrémité du nom de la variable, le code est plus lisible. Si votre chaîne doit contenir des guillemets, vous pouvez utiliser le code d'échappement \\". Par exemple: DebugPrint("Bonjour, \\"Mr. John Doe\\"!") ; ceci affiche bonjour, "Mr. John Doe"! Les codes d'échappement sont toujours spécifiés après le caractère barre oblique inverse (\\). Si vous devez utiliser une barre oblique inverse dans une chaîne utiliser un caractère de barre oblique inverse comme code d'échapement (\\\\). Les séquences d'échappement suivantes sont supportées par Hollywood : \\a émettre un son depuis l'enceinte système \\b retour arrière \\f alimentation papier \\n caractère de saut de ligne \\r retour chariot \\t tabulation horizontale \\v tabulation verticale \\\\ barre oblique inverse (anti-slash) \\"  guillemets \\' apostrophe \\? Point d'interrogation \\[ crochet ouvert \\] fin de crochet \\xxx codes ASCII La dernière séquence d'échappement vous permet d'insérer des caractères ASCII en spécifiant le code après la barre oblique inverse. Les codes ASCII doivent être spécifiés uniquement avec une notation décimale et peut occuper jusqu'à trois chiffres. Les codes ASCII valides vont de 0 à 255. Toutes valeur supérieur à 255 ne pourra être validé. En utilisant cette séquence d'échappement, vous pouvez insérer un caractère zéro dans une chaîne: a$ = "Hello\\0World" Dans beaucoup de langages de programmation un caractère zéro définit l'extrémité de la chaîne. Pas dans Hollywood. Hollywood vous permet d'utiliser autant de caractères zéro que vous le désirez dans vos chaînes. Toutes les fonctions de la @{"bibliothèque chaîne" LINK V6LibString} prennent en compte le caractère zéro. Par exemple, ce code renverrait 11 : DebugPrint(StrLen("Hello\\0World")) Cependant, cela ne s'applique pas aux fonctions qui affiche du texte. L'exemple suivant afichera "Hello" à cause du caractère zéro : DebugPrint("Hello\\0World") ; affiche "Hello" parce qu'un charactère zéro met fin à la chaîne. Si un caractère de saut de ligne suit une barre oblique inverse, Hollywood insérera un saut de ligne dans la chaîne et continuera d'écrire la chaîne sur la prochaine ligne. Par exemple, les deux déclarations suivantes créés la même chaîne de caractères: a$ = "Hello\\nWorld!" a$ = "Hello\\ World!" Si vous utilisez cette méthode, assurez-vous que le caractère de saut de ligne soit exactement placé derrière la barre oblique inverse. Il ne doit y avoir aucun espace/tabulation entre la barre oblique inverse et le saut de ligne. Une autre méthode pour spécifier des chaînes est d'utiliser une paire de crochets. C'est particulièrement utile si vous avez plusieurs lignes de texte qui doivent être mis à l'intérieur d'une chaîne. Un exemple: a$ = [[ My HTML Page http://www.airsoftsoftwair.de/ ]] L'initialisation de chaîne ci-dessus est identique à se code: a$ = "\\n\\nMy HTML Page\\n\\n\\n" .. "http://www.airsoftsoftwair.de/\\n" .. "\\n\\n" Vous remarquez que la première version est beaucoup plus lisible. Si vous voulez utiliser plusieurs lignes de chaînes, utiliser la méthode [[...]]. Si un caractère de saut de ligne se trouve après [[, ce saut de ligne est ignoré. Vous pouvez également librement utiliser des guillemets dans une chaîne délimitée par[[...]]. C'est un autre avantage. @ENDNODE @NODE V6PrgTypeNumber "Guide Hollywood" @{b}Nombre@{ub} Le type nombre peut être utilisé pour enregistrer un nombre entier signé et des nombres réels. L'espace de stockage pour chaque nombre est entièrement en 64 bits, se qui signifie que vous pouvez utiliser de très grands nombres entiers et les nombres précis à virgule flottante. Le type nombre peut théoriquement enregistrer des nombres s'échelonnement de 1.7*10^-308 à 1.7*10^308 bien que vous n'ayez nul besoin dans la pratique de tels nombres. Vous pouvez également spécifier des nombres hexadécimaux en employant le préfixe $ ou 0x. Par exemple: a = $FF ; a = 255 Les nombres à virgule flottante peuvent également être spécifiés en utilisant la notation exponentielle. Par exemple: a = 2.5e5 ; a = 2.5 * 10^5 => a = 250000 Le 0 est optionnel pour des valeurs virgules flottantes entre -1 et 1. Ainsi le code suivant fonctionnerait également : a = .25 * 2 ; a = 0.5 Bien que Hollywood ne sépares pas les types de données pour le nombre entier et à virgule flottante, il reste à la suggestion du programmeur de suffixer les variables pour une question de lisibilité, il est préférable de suffixer avec un point d'exclamation les variables utilisant des valeurs à virgules flottantes. Par exemple: a! = 3.14159265 Ceci facilite la lisibilité de votre code afin de reconnaître les variables contenant des valeurs entières à des variables contenant des valeurs à virgules flottantes. Naturellement, vous pouvez utiliser des valeurs virgules flottantes sans repère d'exclamation, mais il est préférable de les repérer. @ENDNODE @NODE V6PrgFlow "Guide Hollywood" @{b}Déclaration de contrôle de flux de vos programmes@{ub} Ce chapitre décrit toutes les déclarations fournie avec Hollywood, qui sont utilisés pour contrôler le déroulement du programme. Il est très important de connaître ces contrôles de structures parce qu'ils peuvent rendre votre programme beaucoup plus lisible. Nous pouvons classer les structures de contrôle de Hollywood dans deux groupes: 1) Blocs conditionnelles: Ils sont habituellement utilisés pour vérifier si une expression particulière est TRUE (différent de zéro) ou FALSE (zéro). C'est très important parce que votre programme doit prendre des décisions à tout instant. Les blocs conditonnels suivants sont disponible: @{"If-Else-ElseIf-EndIf " LINK V6PrgIf} @{"Switch-Case-Default-EndSwitch " LINK V6PrgSwitch} 2) Boucles: Elles sont utilisées pour répéter certaines parties de votre code. Imaginer que vous voulez affichez les nombres de 1 à 100. Vous pourriez écrire la commande Print() cents fois pour cela, mais vous pourriez également utiliser une simple boucle For qui exécuterait Print() cents fois. Les boucle suivante sont disponibles: @{"While-Wend " LINK V6PrgWhile} @{"For-Next " LINK V6PrgFor} @{"Repeat-Until " LINK V6PrgRepeat} @ENDNODE @NODE V6PrgBlock "Guide Hollywood" @{b}Déclaration Block-EndBlock@{ub} @{b}Block@{ub} @{b}EndBlock@{ub} La déclaration Block exécute simplement le code suivant dans une partie séparé. Cette déclaration est rarement utilisée. Voici un Exemple: For k = 1 To 100 Block Local k For k = 1 To 2 DebugPrint(k) Next EndBlock ; la variable locale "k" est maintenant effacé Next Le code ci-dessus utilise deux variables avec le nom "k" dans deux boucles emboîtées. C'est possible parce que nous mettons la boucle intérieure dans son propre bloc et créé une nouvelle variable locale k dans se bloc. Cette variable locale est seulement accessible dans se bloc. Après la déclaration EndBlock, la variable locale k sera effacé et la variable global k sera utilisé de nouveau. @ENDNODE @NODE V6PrgReturn "Guide Hollywood" @{b}Déclaration Return@{ub} @{b}Return@{ub} [@{b}(@{ub}, , ...@{b})@{ub}] La déclaration Return est utilisé pour quitter une fonction défini par l'utilisateur. Le contrôle du programme reviendra à la position dans le script d'où la fonction est appelé. Eventuellement, Return peut renvoyer autant de valeurs que vous le voulez au demandeur. Si vous renvoyez des valeurs d'une fonction, il est obligatoire de mettre ces valeurs dans des parenthèses. Par exemple: ; code Faux Function p_Min(a, b) If a < b Then Return a Return b EndFunction ; code bon Function p_Min(a, b) If a < b Then Return(a) Return(b) EndFunction Lire: @{"l'introduction aux functions " LINK V6PrgFunctions} @{"les valeurs retournées par les fonctions " LINK V6PrgFuncRetVals} Note de compatibilité: Return peut également être utilisé après une déclaration de label de sorte que le code au label peut être exécuter grâce à Gosub. Cette caractéristique est seulement incluse pour des raisons de compatibilité avec les scripts Hollywood 1.x. Ne plus l'utiliser. @ENDNODE @NODE V6PrgContinue "Guide Hollywood" @{b}Déclaration Continue@{ub} @{b}Continue@{ub} [@{b}(@{ub}@{b})@{ub}] La déclaration Continue peut être utilisé pour sauter à la fin de la boucle. Exemple: While i < 100 i = i + 1 If i > 50 Then Continue j = j + 1 Wend Le code ci-dessus compte i de 0 à 100. La variable j est également incrémenté à chaque boucle mais seulement quand i est inférieur ou égal à 50. Si i est plus grand que 50, j ne sera plus incrémenté. A l'extrémité de la boucle, I a la valeur de 100 et j à la valeur de 50. En utilisant l'argument optionnel , vous pouvez également sauter à la fin d'une autre boucle. Si vous ne spécifiez pas , Hollywood en gérera une pour lui, se qui signifie qu'il sautera à la fin de la boucle la plus proche. Si vous utilisez de plus grandes valeurs pour , Hollywood traversera les boucles vers le haut. Note: Si vous spécifiez l'argument optionnel , il est obligatoire d'utiliser des parenthèses. @ENDNODE @NODE V6PrgBreak "Guide Hollywood" @{b}Déclaration Break@{ub} @{b}Break@{ub} [@{b}(@{ub}@{b})@{ub}] La déclaration Break peut être utilisé pour quitter une boucle ou la déclaration @{"Switch-Case" LINK V6PrgSwitch}. Si vous appelez Break à l'intérieur d'une boucle ou d'une déclaration Switch-Case Hollywood quittera de cette structure de contrôle. Exemple: For k = 1 To 100 DebugPrint(k) If IsKeyDown("ESC") = True Then Break Next La boucle ci-dessus compte de 1 à 100 mais peut être interrompus à tout moment si vous appuyez sur la touche Esc. En utilisant l'argument optionnel , vous pouvez également terminer une autre boucle. Si vous ne spécifiez pas , Hollywood en gérera une pour lui se qui signifie que la boucle la plus proche sera arrêtée. Si vous utilisez de plus grandes valeurs pour , Hollywood traversera les boucles vers le haut. Exemple: For x = 1 To 100 For y = 1 To 100 DebugPrint(x, y) If IsKeyDown("ESC") Then Break(2) Next Next Ce code utilise deux boucles @{"For" LINK V6PrgFor} emboîtés et effectue un test dans la deuxième boucle pour vérifier si la touche Esc est actionnée. Pour arrêter les deux boucles, nous devons utiliser une déclaration Break(2) parce que Break sans indication terminerait seulement la boucle sur y tandis que la boucle sur x continuerais. Note: Si vous spécifiez l'argument optionnel , il est obligatoire d'utiliser des parenthèses @ENDNODE @NODE V6PrgSwitch "Guide Hollywood" @{b}Déclaration Switch-Case@{ub} @{b}Switch@{ub} @{b}Case@{ub} [:] [...] [@{b}Default@{ub}[:] ] @{b}EndSwitch@{ub} La déclaration Switch peut être utilisé pour comparer l'expression spécifiée dans avec toutes autres expressions spécifiées après les identificateurs Case. Vous pouvez utiliser autant de déclaration Case que vous le désirez mais il doit y avoir au moins un identificateur Case dans votre déclaration Switch. Si l'expression après avoir identifié Case avec est vrai, alors le code après la déclaration Case correspondante est effectué. Après l'exécution, Hollywood poursuit votre programme après EndSwitch. Si aucune des expressions Case ne correspond avec , le code suivant l'identificateur default sera exécuté. L'utilisation de l'identificateur default est optionnel. Si vous n'en n'avez pas besoin, ne l'utilisé pas. Les 2 points (:) après les identificateurs case ou default est également optionnel. Noter que l'expression suivant l'identificateur Case doit toujours être une constante. Vous ne pouvez pas utiliser de variables ou des valeurs de renvoi de fonction. De plus vous ne devez pas mélanger différents types de variables dans cette déclaration: Si est une chaîne, toutes les autres expressions doivent être également des chaînes. Si est un nombre, tout les autres expressions doivent être des nombres. Les programmeurs C et Java devraient noter que la déclaration Hollywood Switch ne supporte pas "fall through". Hollywood sautera automatiquement à la fin de la déclaration après qu'un bloc Case ait été exécuté. Donc, vous n'avez pas à utiliser @{"Break" LINK V6PrgBreak} à la fin d'un bloc Case. Mais vous pouvez l'utiliser plus tôt pour sortir de la déclaration Switch. Exemple: Switch x Case 1: DebugPrint("x = 1") Case 2: DebugPrint("x = 2") Default: DebugPrint("x <> 1 And x <> 2") EndSwitch le code ci-dessus regarde la variable x et entre dans la première déclaration Case si x est 1. La deuxième déclaration de Case est exécuté si x est 2. Sinon la déclaration default est validé. Chaque déclaration Switch-Case peut également être écrite comme une @{"déclaration If" LINK V6PrgIf}. L'exemple ci-dessus peut être écrit comme ceci: If x = 1 DebugPrint("x = 1") ElseIf x = 2 DebugPrint("x = 2") Else DebugPrint("x <> 1 And x <> 2") EndIf @ENDNODE @NODE V6PrgRepeat "Guide Hollywood" @{b}Déclaration Repeat-Until@{ub} Il y a deux versions de la déclaration Repeat: Une version conditionnelle et une version sans fin. 1) Version conditionnelle de la déclaration Repeat: @{b}Repeat@{ub} @{b}Until@{ub} La déclaration conditionnelle Repeat répétera le code dans la boucle spécifié jusqu'à se que l'expression donnée devienne vraie(différent de zéro). En d'autres termes: Le bloc peut être bouclé tandis que est faux (zéro). C'est le contraire de la boucle @{"While" LINK V6PrgWhile} qui se comporte ainsi: boucles le code tant que l'expression est vraie et Repeat boucle le code tandis que l'expression est Fausse. Voici un Exemple: i = 1 Repeat i = i + 1 Until i = 100 Ce code compte de 1 à 100. Quand la boucle est terminé, la variable i doit être égal à 100. Lire: @{"Break " LINK V6PrgBreak} @{"Continue " LINK V6PrgContinue} Ils peuvent être utilisées pour quitter d'une boucle ou pour sauter à la fin de celle-ci. 2) Version sans fin de la déclaration Repeat: @{b}Repeat@{ub} @{b}Forever@{ub} La version sans fin peut être utilisée pour répéter une partie de code indéfiniment. Vous pouvez sauter de cette boucle en utilisant la déclaration Break. La version sans fin est la plupart du temps utilisée dans la boucle principale d'un script qui exécute la commande @{"WaitEvent()" LINK WaitEvent}. Par exemple: Repeat WaitEvent Forever @ENDNODE @NODE V6PrgFor "Guide Hollywood" @{b}Déclaration For-Next@{ub} Il y a deux versions pour cette déclaration: Une longue et une version courte. 1) Déclaration longue de For: @{b}For@{ub} [@{b}Local@{ub}] @{b}=@{ub} @{b}To@{ub} [@{b}Step@{ub} ] @{b}Next@{ub} La première chose qu'effectue la déclaration For, est d'initialiser la variable spécifié par à l'expression spécifié par . La valeur de la déclaration Step, spécifié dans , indique comment continuer. Cette valeur est optionnelle. Si vous ne spécifiez pas la déclaration Step, à comme valeur par défaut la valeur 1. Si est positif, la déclaration For vérifiera si la valeur dans la variable est inférieur ou égale à . Si c'est le cas, la boucle sera exécutée et répété jusqu'à ce que la valeur dans soit supérieur à . A l'extrémité de chaque boucle, est ajouté à la valeur de la variable . Si est négatif, la déclaration For vérifiera si la valeur dans la variable est supérieur ou égal à . Si c'est le cas, la boucle sera exécutée et répétée jusqu'à ce que la valeur dans soit inférieur à . A l'extrémité de chaque boucle, est ajouté à la valeur de la variable . Au cas où est égal à zéro, la boucle sera répétée indéfiniment. Noter que les expressions spécifiées dans et sont seulement évaluées une seule fois, au début de la boucle. Ainsi, la limite de la boucle et Step seront constantes tandis que la boucle est active et ne peut pas être modifiée. Un Exemple: For i = 1 To 100 DebugPrint(i) Next Ce code affiche les nombres de 1 à 100. @{"DebugPrint()" LINK DebugPrint} est exécuté cents fois. Quand la boucle quitte, la variable i à la valeur 101. Vous voyez que nous n'avons pas spécifié de déclaration Step. Donc 1 est ajouté chaque fois que la boucle est répétée. Si vous voulez progresser avec le facteur 2, vous pouvez utiliser le code suivant: For i = 1 To 100 Step 2 DebugPrint(i) Next Ceci affichera " 1 3 5 7 9 ... 95 97 99 ". La variable aura une valeur de 101 quand la boucle sera quittée. Si vous voulez décompter de 100 à 0, vous devez utiliser une valeur négative dans Step comme dans l'exemple suivant: For i = 100 To 0 Step -1 DebugPrint(i) Next Ceci exécute DebugPrint() 101 foid. Après la sortie de boucle, la variable i a la valeur -1. Si vous ajoutez l'identificateur local avant l'initialisation de la variable, la déclaration For créra la variable d'itération localement dans le bloc de la boucle. Se qui signifie qu'il ne peut pas être consulté de l'extérieur du bloc de la boucle. Exemple: For Local i = 1 To 50 DebugPrint(i) ; affiche 1, 2, 3 ... 49, 50 Next DebugPrint(i) ; affiche 0 parce que la variable i est seulement disponible à l'intérieur de la boucle. L'avantage des boucles For qui utilisent une variable locale d'itération est qu'elles fonctionnent plus rapidement que les boucles qui utilisent une variable globale. Si vous n'avez pas besoin d'accéder à la variable de la déclaration For à l'extérieur de la boucle, vous devez toujours utiliser l'identificateur local. La limitation des boucles For avec l'identification Local est, que vous ne devez pas affecter une nouvelle valeur dans la valeur d'itération local. Si vous devez quitter la boucle, utiliser @{"Break" LINK V6PrgBreak}. Modifier la variable d'itération pendant l'exécution de la boucle fonctionne seulement sans l'identificateur local. Lire: @{"Break " LINK V6PrgBreak} @{"Continue " LINK V6PrgContinue} Elles peuvent être utilisées pour quitter d'une boucle ou pour sauter à la fin de celle-ci. 2) Déclaration courte de For: @{b}For@{ub} [@{b}Local@{ub}] @{b}=@{ub} @{b}To@{ub} [@{b}Step@{ub} ] @{b}Do@{ub} La version courte se comporte exactement comme la version longue mais vous n'avez pas besoin d'indiquer la déclaration Next. La déclaration courte For à la restriction que le bloc boucler doit seulement se composer d'une déclaration. Si vous avez besoin d'accomplir plusieurs déclaration dans le bloc boucler, vous devez utiliser la version longue. L'identificateur Do signale à Hollywood que vous voulez utiliser la version courte. Le premier exemple ci-dessus peut être écrit de la façon suivante en utilisant la déclaration courte For: For i = 1 To 100 Do DebugPrint(i) @ENDNODE @NODE V6PrgWhile "Guide Hollywood" @{b}Déclaration While-Wend@{ub} Il y a deux versions de la déclaration While: Une longue et une version courte. 1) Déclaration longue de While: @{b}While@{ub} @{b}Wend@{ub} La déclaration While active la boucle si l'expression donnée est vraie (différent de zéro). Si l'expression est fausse (zéro), la boucle ne sera pas exécutée et l'exécution continuera après la déclaration Wend. Si While active la boucle, elle répéterà la boucle tant que l'expression donnée est vraie. i = 0 While i < 100 i = i + 1 Wend DebugPrint(i) ; affiche 100 La boucle ci-dessus sera répétée jusqu'à se que l'expression i < 100 devienne fausse. C'est le cas quand i est égal ou supérieur à 100. Puisque nous commençons à partir de 0 et que nous additionnons i de 1 après chaque cycle de boucle, i aura la valeur de 100 quand la boucle sera terminée. Lire: @{"Break " LINK V6PrgBreak} @{"Continue " LINK V6PrgContinue} Elles peuvent être utilisés pour quitter une boucle ou pour sauter à la fin de celle-ci. 2) Déclaration courte de While: @{b}While@{ub} @{b}Do@{ub} La version courte se comporte exactement comme la version longue mais vous n'avez pas à indiquer la déclaration Wend. La déclaration courte While à la restriction que le bloc à boucler doit seulement se composer que d'une déclaration. Si vous avez besoin d'exécuter plusieurs déclaration dans le bloc à boucler, vous devez utiliser la version longue. L'identificateur Do signale à Hollywood que vous voulez utiliser la version courte. L'exemple ci-dessus peut être écrit de la façon suivante en utilisant la décaration courte Short: While i < 100 Do i = i + 1 @ENDNODE @NODE V6PrgIf "Guide Hollywood" @{b}Déclaration If-EndIf@{ub} Il y a deux versions de la déclaration If: Une longue et une version courte. 1) Déclaration longue de If: Syntaxe : @{b}If@{ub} [@{b}ElseIf@{ub} ...] [@{b}Else@{ub} ] @{b}EndIf@{ub} La déclaration If vérifie si l'expression donnée est vraie (différent de zéro). Si c'est le cas, les commandes suivant cette déclarations seront exécutées. Si l'expression donnée est fausse(zéro), If effectuera un saut à la prochaine déclaration ElseIf (s'il y en a une) et vérifie si l'expression donnée est vraie. Ceci est répété jusqu'à ce que la déclaration Else soit atteinte. Si aucune des expressions étaient vraies, le code se trouvant après Else sera exécuté. Les déclarations If et EndIf sont obligatoire. les déclarations ElseIf et Else sont optionnelles. Vous pouvez utiliser autant de fois ElseIf que vous le désirez mais il doit y avoir seulement un seul Else dans votre déclaration If. En outre la déclaration Else doit être la dernière condition avant EndIf. Voici un Exemple: If a > 5 ; vérifie si a est plus grand que 5 DebugPrint("a > 5") ElseIf a < 5 ; vérifie si a est inférieur à 5 DebugPrint("a < 5") Else ; alors a=5 DebugPrint("a = 5") EndIf Vous pouvez également utiliser des expressions plus complexes comme condition: If country$ = "USA" And age < 21 DebugPrint ("aucun alcool est autorisé au-dessous de 21 ans aux Etats-Unis!") EndIf 2) Déclaration courte de If: Syntaxe : @{b}If@{ub} @{b}Then@{ub} [@{b}ElseIf@{ub} ...] [@{b}Else@{ub} ] La version courte de la déclaration If fonctionne de la même façon que la version longue mais a l'avantage que vous n'avez pas besoin d'inclure EndIf. La déclaration courte de If a une restriction, c'est que toutes les parties doivent être mis sur une seule ligne. Une autre restriction est, qu'une déclaration seulement doit suivre les identificateurs Then/ElseIf/Else. Si vous voulez exécuter plusieurs déclarations, vous devez utiliser la version longue. En utilisant la déclaration courte de If vous permez d'écrire l'exemple ci-dessus de la façon suivante: If a > 5 Then DebugPrint("a > 5") ElseIf a < 5 DebugPrint("a < 5") Else DebugPrint("a = 5") Vous pouvez vous rendre compte que le résultat n'est pas très lisible, ainsi dans le cas de l'exemple ci-dessus, il n'est pas recommandé d'utiliser la version courte. La déclaration courte de If améliore la lisibilité si vous avez juste une condition. Par exemple: If a = True Then b = 5 C'est plus lisible que If a = True b = 5 EndIf * * * Une autre version de la déclaration If est le If immédiat IIf(). Cette version est mis en application comme une commande Hollywood et elle fait partie de la bibliothèque système. Regarder @{"ici" LINK IIf} pour la documentation d'IIf(). @ENDNODE @NODE V6PrgFuncVar "Guide Hollywood" @{b}Les Fonctions sont des variables@{ub} Dans Hollywood, les fonctions sont des variables de type fonction. Par conséquent vous pouvez facilement les affecter à d'autres variables, par Exemple: myfunc = DisplayBrush ; affecter DisplayBrush à "myfunc" myfunc(1, #CENTER, #CENTER) ; exécute DisplayBrush(1, #CENTER, #CENTER) Vous pouvez même écrire la définition d'une fonction comme une assignation: p_Add = Function(a, b) Return(a + b) EndFunction c = p_Add(5, 2) ; c reçoit 7 La définition de "p_Add" dans la première ligne est identique à se qui peut être écrite comme suit: Function p_Add(a, b) Return(a + b) EndFunction Vous pouvez également remplacer les fonctions d'Hollywood par vos propres fonctions, par exemple si vous voulez que tous les appels de @{"Print()" LINK Print} utilisent @{"DebugPrint()" LINK DebugPrint} à la place, le code suivant peut faire ceci: Function p_Print(...) DebugPrint(Unpack(arg)) ; indique tous les éléments du tableau le "arg" dans DebugPrint() EndFunction Print = p_Print ; tous les appels de Print() appelleront p_Print () Print("Hello World!") ; Print() se rapporte à p_Print () Ou une solution encore plus simple : Print = DebugPrint ; diriger à nouveau tous les appels de Print() à DebugPrint() Print("Hello World!") ; appels directement DebugPrint() @ENDNODE @NODE V6PrgFuncRec "Guide Hollywood" @{b}Fonction récursive@{ub} Hollywood supporte les fonctions récursives, c.-à-d. que vous pouvez écrire des fonctions qui s'appel eux-mêmes. Par exemple, voici une fonction qui calcule avec le facteur de n: Function p_Fac(n) If n = 0 Then Return(1) ; 0! = 1 Return(n * p_Fac(n - 1)) ; multiplier n avec n - 1 jusqu'à n = 0 EndFunction Comme vous pouvez voir ci-dessus, la fonction p_Fac() s'appels elle-même à plusieurs reprises jusqu'à se que le compteur n soit égal à zéro. Voilà se que nous appelons une fonction récursive. @ENDNODE @NODE V6PrgFuncVarArgs "Guide Hollywood" @{b}Un nombre variable d'arguments@{ub} Vous pouvez également écrire des fonctions qui reçoivent n'importe quel nombre d'arguments. Pour effectuer ceci, vous devez utiliser l'identificateur "..." comme dernier paramètre. Votre fonction obtiendra alors un tableau local appelé "arg" qui contiendra tous les paramètres qui ont été indiqués dans votre fonction comprenant un élément appelé "n" qui transporte le nombre de paramètres qui ont été indiqués dans la fonction. Noter également que les arguments seront enregistrés dans le tableau "arg" commencant à l'index 0. Par exemple, voici une fonction qui calcule la moyenne de tous les paramètres qui lui ont été indiqué: Function p_Average(...) Local pars = arg.n ; combien de paramètres ont été indiqués Local avg, k ; temporairement Locale For k = 1 To pars avg = avg + arg[k-1] ; résumer tous les paramètres Next Return(avg / pars) ; et divise le montant par leur quantité EndFunction a = p_Average(10, 20, 30, 40, 50) ; (10 + 20 + 30 + 40 + 50) / 5 = 30 b = p_Average(34, 16, 27, 39) ; (34 + 16 + 27 + 39) / 4 = 29 c = p_Average(10, 10) ; (10 + 10) / 2 = 10 Print(a, b, c) ; affiche "30 29 10" Il est important de noter que l'identificateur "..." doit être spécifié en tant que dernière entrée de votre liste de paramètre. Vous ne pouvez pas effectué des choses comme ceci: ; code incorrect Function p_Test(a, b, ..., c) ... EndFunction Ceci ne fonctionnera évidemment pas parce que Hollywood ne saurait pas quel paramètre appartient à "c". En utilisant des paramètres avant l'identificateur "..." fonctionne très bien cependant : Function p_MinMax(ismin, ...) Local pars = arg.n ; nombre de paramètre indiqué Local k If ismin = True ; découvrir le plus petit élément Local min = arg[0] ; enregistrer le plus petit élément ici For k = 2 To pars ; itération sur tous les éléments If arg[k-1] < min Then min = arg[k-1] ; plus petit ? Next Return(min) ; et retourne le plus petit Else Local max = arg[0] ; enregistrer l'élément le plus grand ici For k = 2 To pars ; itération sur tous les éléments If arg[k-1] > max Then max = arg[k-1] ; plus grand ? Next Return(max) ; et retourne l'élément le plus grand EndIf EndFunction a = p_MinMax(True, 4, 8, 2, 3, 10, 1, 7, 9, 5, 6) ; retourne 1 b = p_MinMax(False, 4, 8, 2, 3, 10, 1, 7, 9, 5, 6) ; retourne 10 Cette fonction retournera le plus petit nombre du paramètres spécifiés si le premier argument est TRUE ou le plus grand nombre si le premier argument est réglé à FALSE. Si vous devez indiquer tous les arguments vers une autre fonction, la commande @{"Unpack()" LINK Unpack} peut devenir maniable. Elle renverra tous les éléments d'un tableau. Par exemple, si vous voulez écrire vos propres commande @{"Print()" LINK Print}: Function p_Print(...) Print(Unpack(arg)) EndFunction Tous les arguments indiqués dans p_Print() seront indiqués dans @{"Print()" LINK Print} en utilisant la commande @{"Unpack()" LINK Unpack}. @ENDNODE @NODE V6PrgFuncLoc "Guide Hollywood" @{b}Fonction locale@{ub} Puisque toutes les fonctions Hollywood sont juste des variables du type "fonction", vous pouvez également utiliser les fonctions locales qui ont une vie limitée. Ils fonctionnent de la même façon que les @{"variables locales " LINK V6PrgLocals} et ont aussi les mêmes avantages. Voici un exemple d'une fonction local: Block ; créer un nouveau bloc Local p_Add = Function(a, b) Return(a + b) EndFunction ; défini la fonction local p_Add() Print(p_Add(5, 6)) ; affiche 11 EndBlock ; p_Add () est effacé Vous pouvez également utiliser la définition de la fonction la plus courante pour créer des fonctions locales. Ce code fait la même chose que le code ci-dessus : Block ; créer un nouveau bloc Local Function p_Add(a, b) Return(a + b) EndFunction ; défini la fonction local p_Add() Print(p_Add(5, 6)) ; affiche 11 EndBlock ; p_Add () est effacé Utiliser des fonctions locales peut également être maniable si vous voulez à temporairement remplacer une fonction Hollywood. Par exemple, le code suivant remplace la fonction DebugPrint() avec le fonction Print() mais seulement dans le bloc où il a été défini (et dans les blocs subalternes) : If error = True Local Function DebugPrint(...) Print(Unpack(arg)) EndFunction DebugPrint("Une erreur est survenue!") ; appel la command Hollywood Print() EndIf DebugPrint("Bonjour") ; appel la commande Hollywood DebugPrint() La chaîne "Une erreur est survenue!" sera affiché sur votre écran dans le code ci-dessus parce que nous avons défini une fonction local appelé @{"DebugPrint()" LINK DebugPrint}qui appelle le commande Hollywood @{"Print()" LINK Print}. DebugPrint() sera détruit quand le bloc sera quitté. L'appel suivant à DebugPrint() appellera alors la vraie commande Hollywood DebugPrint(). @ENDNODE @NODE V6PrgFuncCallback "Guide Hollywood" @{b}Fonction de rappel de service@{ub} Plusieurs commandes Hollywood vous permettent de spécifier des fonctions de rappel de service. Les fonctions de rappel de service sont des fonctions normales de Hollywood mais la différence est, qu'elles ne s'appellent pas par le script mais par les commandes Hollywood. Elles font partie intégrante de Hollywood et rendent votre programme plus souple. Le système de bouton et le gestionnaire d'événement d'Hollywood 2.0 sont fortement accés sur les fonctions de rappel de service. Par exemple, si l'utilisateur appuie sur votre bouton, alors Hollywood exécutera une fonction de rappel de service qui est fourni pour cet événement particulier. les fonctions de rappel de service sont simplement indiqués en tant qu'arguments normaux aux commandes Hollywood correspondantes. Un exemple d'une commande Hollywood qui utilise des fonctions de rappel de service est la commande @{"MakeButton()" LINK MakeButton}. Cette commande attend un tableau dans le septième paramètre, qui définit des fonctions de rappel de service pour les différents événements qui peuvent se produire. Les événements possibles pour un bouton sont OnMouseOver, OnMouseOut, OnMouseDown OnMouseUp, OnRightMouseDown et OnRightMouseUp. Si vous voulez simplement réagir quand le bouton est pressé, utiliser l'événement OnMouseUp. Cet événement sera déclenché quand l'utilisateur relâche le bouton gauche de la souris tandis que le pointeur de la souris est au-dessus du bouton. Voici un Exemple: MakeButton(1, #SIMPLEBUTTON, 0, 0, 100, 100, {OnMouseUp = p_MyFunc}) Cette commande créé un nouveau bouton avec l'identificateur 1 et définit que la fonction p_MyFunc() sera appelé, quand l'utilisateur appuie sur ce bouton. Dans ce cas, p_MyFunc () est une fonction de rappel de service. Elle ne s'appellera pas appelé par vous mais par Hollywood, quand l'utilisateur appuie sur le bouton. Ceci fonctionne automatiquement. Plus précisément, les fonctions de rappel de service seront appellé par la commande Hollywood @{"WaitEvent()" LINK WaitEvent} que vous devez utiliser dans chaque script. La fonction de rappel de service elle-même peut ressembler à sa: Function p_MyFunc() DebugPrint("Bouton 1 pressé!") EndFunction Vous pourriez également mettre cette fonction directement dans la liste d'arguments de MakeButton(). Ceci ressemblerait à sa: MakeButton(1, #SIMPLEBUTTON, 0, 0, 100, 100, {OnMouseUp = Function() DebugPrint("Bouton 1 pressé!") EndFunction}) Vous voyez que Hollywood est très souple. Rappeler vous que si vous déclarez des fonctions dans une liste d'arguments d'un appel, vous ne devez pas fournir le nom de la fonction parce que ces fonctions sont anonymes. Donc le code suivant serait incorrect: ; code incorrect MakeButton(1, #SIMPLEBUTTON, 0, 0, 100, 100, {OnMouseUp = Function p_MyFunc() DebugPrint("Bouton 1 pressé!") EndFunction}) Les fonctions de rappel de service reçoivent habituellement un tableau de message dans le paramètre 1. Dans l'exemple ci-dessus, nous n'avons pas cherché ce message parce que nous avons déclaré la fonction sans arguments. Pour le code ci-dessus, c'est très bien mais imaginer l'exemple suivant : MakeButton(1, #SIMPLEBUTTON, 0, 0, 100, 100, {OnMouseUp = p_MyFunc}) MakeButton(2, #SIMPLEBUTTON, 200, 0, 100, 100, {OnMouseUp = p_MyFunc}) Maintenant nous avons déclaré deux boutons mais les deux appellent la même fonction quand l'utilisateur les actionnes. La fonction p_MyFunc() doit savoir quel bouton a été appuyé quand il est appelé. p_MyFunc() peut le découvrir en analysant le message qu'il reçoit dans l'argument 1: Function p_MyFunc(msg) If msg.id = 1 DebugPrint("Bouton 1 pressé!") ElseIf msg.id = 2 DebugPrint("Bouton 2 pressé!") EndIf EndFunction Vous voyez que p_MyFunc() analyse l'indicateur id du message qu'il a reçu dans l'argument 1 et ainsi il peut distinguer le bouton 1 et 2. Naturellement, vous pouvez étendre cela à n'importe quel quantité de boutons. Mais il y a plus à regarder. Considérer la situation suivante: evttable = {OnMouseUp = p_MyFunc, OnRightMouseUp = p_MyFunc} MakeButton(1, #SIMPLEBUTTON, 0, 0, 100, 100, evttable) MakeButton(2, #SIMPLEBUTTON, 200, 0, 100, 100, evttable) MakeButton(3, #SIMPLEBUTTON, 400, 0, 100, 100, evttable) Maintenant nous avons déclaré trois boutons et ils sont tous utilisé dans le même tableau d'événement. Ainsi Hollywood appellera le même fonction pour tous les boutons. En outre, ces boutons réagissent sur un autre événement, à savoir OnRightMouseUp. Maintenant p_MyFunc() doit être en mesure de discerner non seulement entre plusieurs boutons mais également entre différents événements. Mais ce n'est pas un problème du tout parce que le message indiqué dans p_MyFunc() à un autre indicateur dont vous pouvez lire l'événement qui a entraîné l'appel de la fonction. Notre fonction p_MyFunc () ressemblerait à sa: Function p_MyFunc(msg) Switch msg.action Case "OnMouseUp": DebugPrint("L'utilisateur a pressé le bouton", msg.id, "avec le bouton gauche de la souris!") Case "OnRightMouseUp": DebugPrint("L'utilisateur a pressé le bouton", msg.id, "avec le bouton gauche de la souris!") EndSwitch EndFunction Ainsi vous voyez qu'il n'y a aucun problème pour traiter de multiples boutons et événements avec la même fonction de rappel de service. Ceci augmente la lisibilité de votre programme. Il y a beaucoup plus à découvrir lire la documentation au sujet de @{"MakeButton()" LINK MakeButton}. * * * Si vous voulez être informé quand l'utilisateur ferme ou déplace la fenêtre, vous pouvez installer une fonction de rappel de service en utilisant @{"InstallEventHandler()" LINK InstallEventHandler}. la fonction que vous indiquez dans cette commande Hollywood sera appellé chaque fois que l'utilisateur clique sur le gadget de fermeture ou déplace la fenêtre. Mais InstallEventHandler() supporte bien plus d'événement: Vous pouvez également installer une fonction de rappel de service sera invoqué si l'utilisateur actionne ou relâche une touche et bien plus. La commande Hollywood @{"SetInterval()" LINK SetInterval} utilise également les fonctions de rappel de service. La fonction indique SetInterval() sera appelé à plusieurs reprises à l'interval spécifié. C'est utile si vous voulez vous assurer que votre script fonctionne à la même vitesse sur chaque système. Pour se rendre compte de cela utiliser simplement SetInterval() pour dire à Hollywood, qu'il doit faire fonctionner votre fonction de rappel de service 25 fois par seconde. Ainsi vous pourrez vous assurer qu'il ne fonctionne pas plus rapidement sur des machines plus rapides. Lire la documentation de @{"SetInterval()" LINK SetInterval}. @{"SetTimeout()" LINK SetTimeout} est un autre exemple de commande Hollywood avec laquelle fonctionne la fonction de rappel de service. Vous pouvez indiquer une fonction comme une valeur du dépassement de durée dans SetTimeout(). Votre fonction de rappel de service sera alors appellé après que le temps spécifié se soit écoulé. C'est très utile pour un calage de votre script, par exemple le calage de votre script avec de la musique. Enfin, la commande Hollywood @{"CopyFile()" LINK CopyFile} reçoit une fonction dans le quatrième paramètre. Cette fonction sera appellée de temps en temps tandis que CopyFile() copiera des fichiers. Ceci est une différence aux fonctions de rappel de service de MakeButton (), SetInterval (), SetTimeout () etc. seront toujours appelés par WaitEvent() et pas par la commande Hollywood. La commande CopyFile() cependant appel la fonction spécifié quand elle fonctionne. Ainsi vous pouvez effacer votre fonction de rappel de service après que CopyFile() soit effectué (vous pouvez effacer la fonction en la définisant avec @{"Nil" LINK V6PrgTypeNil}). Ce n'est pas possible avec MakeButton() ou SetInterval(), parce que ces fonctions installent juste des fonctions de rappels de service mais ils ne les invoquent pas. Cette tâche est laissée à WaitEvent(). La fonction de rappel de service de CopyFile() est habituellement utilisé pour mettre à jour une barre de progression ou pour interrompre la fonction de copie à tout moment. Voir la documentation de @{"CopyFile()" LINK CopyFile} pour plus d'information. @ENDNODE @NODE V6PrgFuncTable "Guide Hollywood" @{b}Les fonctions comme membre de tableau@{ub} Les fonctions Hollywood sont juste des variables du type "fonction". Par conséquent, vous pouvez les utiliser la où vous pouvez utiliser les variables. Ceci comprend des tableaux. Vous pouvez enregistrer des fonctions comme des chaîne ou les valeurs à l'intérieur d'un tableau et les appeler de là. Voici un Exemple: mathlib = {} ; créer un tableau vide Function mathlib.add(a, b) Return(a + b) EndFunction Function mathlib.sub(a, b) Return(a - b) EndFunction Function mathlib.mul(a, b) Return(a * b) EndFunction Function mathlib.div(a, b) Return(a / b) EndFunction a = mathlib.mul(5, 10) ; a reçoit la valeur 50 Le tableau mathlib contient quatre fonctions que vous pouvez appeler. Naturellement, vous pouvez également déclarer des fonctions pendant l'initialisation de se tableau. Ceci ressemblerait à ce qui suit: mathlib = {add = Function(a, b) Return(a + b) EndFunction, sub = Function(a, b) Return(a - b) EndFunction, mul = Function(a, b) Return(a * b) EndFunction, div = Function(a, b) Return(a / b) EndFunction} a = mathlib.mul(5, 10) ; a reçoit la valeur 50 Ce code fait exactement les mêmes chose que le code au-dessus mais il est plus compact. Les fonctions à l'intérieur d'un tableau sont également souvent connu sous le nom de "méthodes". C'est un terme utilisé dans le monde de la programmation orientée objet. @ENDNODE @NODE V6PrgFuncRetVals "Guide Hollywood" @{b}Valeur de renvoie@{ub} Si votre fonction renvoie une ou plusieurs valeurs, il est forcé de spécifier ces valeurs entre parenthèses. Ceux-ci sont exigés parce qu'autrement l'analyseur syntaxique les traitera en tant que déclarations séparés. Imaginer le code suivant: ; code erroné Function p_Max(a, b) If a > b Then Return a Return b EndFunction L'analyseur syntaxique de Hollywood interpréterait se code de la façon suivante: Function p_Max(a, b) If a > b Then Return ; si a > b, alors elle ne retournera aucune valeur a ; exécute la fonction a() Return ; Retourne aucune valeur b ; exécute la fonction b() EndFunction Vous voyez, ceci ne semble pas très raisonnable. Les parenthèses sont obligatoires, parce que Hollywood vous permet d'introduire autant de commandes que vous le souhaitez dans une ligne sans séparateurs. Et Hollywood vous permet d'appeler des fonctions qui ne reçoivent pas d'arguments sans "()" parenthèses. Par conséquent une déclaration comme "Return" est converti en deux déclarations, à savoir "Return" et "a()". Si vous voulez retourner la variable a, vous devez écrire "Return(a)". La version correcte de notre fonction p_Max() ressemblerait à ceci: Function p_Max(a, b) If a > b Then Return(a) Return(b) EndFunction En utilisant les parenthèses, vous prouvez à Hollywood que les variables "a" et "b" appartiennent à l'appel Return() et ne sont pas des fonctions séparés. Si une fonction retourne plus d'une valeur mais que vous avez seulement besoin que de la première valeur de renvoi, vous devrez mettre des parenthèses autour de l'appel de fonction. Ceci combinera le résultat de cette fonction dans une seule valeur. Par exemple, la fonction suivante renvoie trois valeurs: Function p_ThreeVals() Return(1, 2, 3) EndFunction Si vous utilisez cette fonction dans une fonction qui reçoit plusieurs arguments par exemple @{"DebugPrint()" LINK DebugPrint}, chacune des trois valeurs de renvoi sera indiqué à DebugPrint(): DebugPrint(p_ThreeVals()) ; affiche "1 2 3" Si vous voulez que DebugPrint() obtienne seulement la première valeur de renvoi de p_ThreeVals(), vous devez mettre des parenthèses autour de l'appel p_ThreeVals() de sorte qu'il ressemble à ceci: DebugPrint((p_ThreeVals())) ; affiche "1" * * * Les fonctions peuvent non seulement renvoyer des nombres, mais également des chaînes, tableaux et même fonctions. Par exemple, le code suivant est valide: Function p_Return_a_Table() Return({1, 2, 3, 4, 5}) EndFunction a = p_Return_a_Table() DebugPrint(a[3]) ; affiche 4 Dans la pratique, vous n'utiliserez probablement pas cette caractéristique mais vous devez savoir, que cela est possible, d'avoir des fonctions qui retournent des tableaux ou d'autres fonctions. Un autre Exemple: Function p_Return_Func() Return(Function DebugPrint EndFunction) EndFunction myfunc = p_Return_Func() myfunc("Hello World!") ; appel DebugPrint("Hello World!") @ENDNODE @NODE V6PrgFunctions "Guide Hollywood" @{b}Fonctions@{ub} Des fonctions peuvent être utilisés pour décomposer votre programme en plusieurs morceaux de codes qui augmente la lisibilité et la structure de votre code. la fonction peut être considéré comme un petit programme. Il peut utiliser des variables qui sont local à la fonction, cela signifie qu'elles seront seulement disponibles à l'intérieur de la fonction et ne peut pas être consulté de l'extérieur. Naturellement, vous pouvez accéder également aux variables globales depuis une fonction. Le Synonyme pour le terme "fonction" est "procédure" "sous-routine" ou "déclaration". Les fonctions peuvent ne rien retourner ou plusieurs valeurs de tout type. Vous pouvez déclarer vos propres fonctions en utilisant la fonction d'identificateurs et EndFunction: Function p_Add(a, b) Return(a + b) EndFunction c = p_Add(5, 2) ; c reçoit la valeur 7 Vous devez toujours utiliser le préfixe "p_" dans vos propres noms de fonction. Cela aide pour distinguer vos propres fonctions aux fonctions Hollywood. De plus, dans les versions futures de Hollywood il pourrait y avoir des fonctions qui ont le même nom que vos fonctions de vos script. Ceci peut engendrer des résultats inattendus. Vous devez toujours utiliser "p_" dans vos noms de fonction afin d'éviter toute confusion. p_ représente "Fonction privé" (ou plutôt procédure). Ces fonctions doivent être déclarés avant d'être appelé, le code suivant vous donnera une erreur: c = p_Add(5, 2) Function p_Add(a, b) Return(a + b) EndFunction Hollywood essayera d'appeler la fonction "p_Add" mais ne le trouvera pas parce qu'elle n'a pas encore été déclaré. Les deux variables "a" et "b" seront locales à la fonction se qui signifie que vous pouvez seulement y accéder à l'intérieur de la fonction p_Add (). Si vous indiquez plus d'arguments dans la fonction qu'elle le prévoit, par exemple: c = p_Add(5, 2, 4) ; c reçoit la valeur 7 alors tous les arguments superflus seront écartés. Dans ce cas l'argument numéro 3 sera effacé. Si vous indiquez moins d'arguments que la fonction le prévoit par exemple: c = p_Add(5) ; c reçoit la valeur 5 parce que 5 + Nil = 5 alors Hollywood indiquerà la valeur spéciale @{"Nil" LINK V6PrgTypeNil} pour tous les arguments, que la fonction prévoit mais qui n'ont pas été spécifiés. Les fonctions peuvent renvoyer des valeurs en utilisant la déclaration Return(). Il est obligatoire que les valeurs de renvoi soient mises entre parenthèses. Si vous devez retourner plusieurs valeurs, les séparer simplement en utilisant des virgules. Par Exemple: Function p_SomeValues() Return(5, 6, 7, 8, 9, 10) EndFunction Quand vous appelez les fonctions qui renvoient plusieurs arguments et que vous ne spécifié pas assez de variables pour maintenir toutes les valeurs de renvoi toutes les valeurs de renvoient que vous n'avez pas spécifié seront écartés, par exemple: a, b, c = p_SomeValues() La ligne ci-dessus affecte 5 à "a", 6 à "b" et 7 à "c". Les valeurs de renvoi 8 9 et 10 seront écartés. Si vous spécifiez plus de variables qu'il y a les valeurs de renvoi, les variables superflues obtiendront la valeur spéciale @{"Nil" LINK V6PrgTypeNil}: a, b, c, d, e, f, g, h = p_SomeValues() ; les variables "g" et "h" seront à Nil. Cette ligne a deux variables superflues "g" et "h". Ils seront affectés de la valeur @{"Nil" LINK V6PrgTypeNil} parce que la fonction p_SomeValues() renvois seulement 6 valeurs. Naturellement, vous pouvez également définir des fonctions qui ne renvoient aucune valeur. Ces fonctions sont des déclarations également appelés. Par Exemple: Function p_WaitSecs Wait(s, #SECONDS) EndFunction Si vous essayez d'obtenir une valeur de renvoi depuis une déclaration, vous recevrez juste @{"Nil" LINK V6PrgTypeNil} suivant les indications de la ligne suivante: a = p_WaitSecs(5) La variable "a" sera réglé à @{"Nil" LINK V6PrgTypeNil} parce que p_WaitSecs() ne retourne pas de valeur. Plus d'information sur les fonctions dans Hollywood : @{"Les fonctions sont des variables " LINK V6PrgFuncVar} chaque fonction est une variable normale @{"Fonction de rappel de service " LINK V6PrgFuncCallback} apprendre à utiliser les fonctions de rappel de service @{"Les valeurs de renvoi  " JOIGNENT V6PrgFuncRetVals} informations avancées sur les valeurs de renvoi @{"Fonction récursive " LINK V6PrgFuncRec} Hollywood accépte la récursion @{"Un nombre variable d'arguments " LINK V6PrgFuncVarArgs} comment traiter les différents arguments @{"Les fonctions comme membre de tableau " LINK V6PrgFuncTable} des fonctions peuvent également être utilisées dans les tableaux @{"Fonction locale " LINK V6PrgFuncLoc} les fonctions peuvent également être locale @ENDNODE @NODE V6PrgG2KTutorial "Guide Hollywood" @{b}Tutoriel - votre diaporama Hollywood en 10 étapes!@{ub} Ce petit tutoriel vous montre comment créer votre propre diaporama pas à pas. Essayer de comprendre que chaque étape qui est écrite ici et vous serait bientôt en mesure de créer vos propres scripts. Les éléments suivants sont exigées pour ce tutoriel: 1) L'image de fond appelé BG.iff avec deux flèches. Le rectangle entourant la flèche 1 est X: 4, Y: 430, L: 35, H: 19. Le rectangle entourant la flèche 2 est X: 591, Y: 430, L: 35, H: 19. L'endroit où les images seront affichées aux coordonnées X: 29, Y: 41. 2) 11 images nommées "0.jpg", "1.jpg", "2.jpg" ... "10.jpg" de la taille en pixel de 571x377 3) Un module Protracker nommé MyMusic.mod Naturellement tous est déjà préparé pour ce tutoriel. Elles sont dans votre répertoire Hollywood dans Help/Tutorial. Copier ces fichiers dans le répertoire où vous avez créé votre script. Suivre alors ces dernières opérations: 1) Mettre en marche votre éditeur de texte préféré 2) L'image de fond pour votre diaporama est une image que vous avez préalablement créé avec votre logiciel de dessin préféré. Dans notre exemple j'ai préparé une image de fond. Vous pouvez voir cette image de fond ici: @{"BG.iff" LINK "Tutorial/BG.iff/MAIN"}. 3) Maintenant nous devons dire à Hollywood qu'il utilisera le fichier BG.iff comme première image de fond. Ceci est fait en le spécifiant avec la commande préprocesseur @BGPIC avec BG.iff. Ainsi vous devez écrire le code suivant dans votre fichier script: @BGPIC 1, "BG.iff" Cette commande indique à Hollywood d'utiliser BG.iff comme image de fond initial. L'image de fond initiale doit toujours avoir l'identificateur 1. S'il n'y a aucune image de fond avec l'identificateur 1, Hollywood créra un écran neutre. 4) Notre présentation aura également une musique de fond. Cette musique est un module Protracker avec le nom MyMusic.mod. Ainsi nous ajoutons la ligne suivante à notre script: @MUSIC 1, "MyMusic.mod" 5) Maintenant nous devons définir des zones dans notre image de fond qui seront accessible comme boutons. Comme vous pouvez le voir, il y a deux flèches dans @{"l'image de fond" LINK "Tutorial/BG.iff/MAIN"}. Comme tous les boutons doivent être défini comme rectangle, nous devons découvrir les coordonnées ainsi que la largeur et la hauteur de chaque flèche. Vous pouvez utiliser un logiciel de dessin comme PPaint pour découvrir les coordonnées. Pour notre image de fond, la flèche gauche est dans un rectangle avec les coordonnées 4:430 (coin en haut à gauche) et la largeur/hauteur de 35/19. Ainsi nous pouvons ajouter la flèche gauche comme bouton 1 à notre script en écrivant le code suivant dans le fichier script : MakeButton(1, #SIMPLEBUTTON, 4, 430, 35, 19, {OnMouseUp = p_Back}) Nous pouvons faire la même chose maintenant avec la flèche à droite qui est dans un rectangle qui commence à 591:430 avec les mêmes cotes que la flèche 1. Ainsi nous sauvons le mot clé suivant en notre séquence type: MakeButton(2, #SIMPLEBUTTON, 591, 430, 35, 19, {OnMouseUp = p_Forward}) Maintenant nous avons défini deux boutons qui peuvent être utilisés. Si le bouton 1 obtient un clique, Hollywood appellerà la fonction p_Back(). Si le bouton 2 obtient un clique, Hollywood appellerà la fonction p_Forward(). 6) Maintenant nous pouvons commencer à ajouter un groupe de commandes qui indiquera à Hollywood ce qui faut faire. Au début,nous voulons que la musique de fond commence à être joué. Comme nous avons déclaré MyMusic.mod comme musique avec le nombre 1. Nous appelons maintenant @{"PlayMusic()" LINK PlayMusic} avec l'argument 1. Ajoutons la ligne suivante à votre script et Hollywood jouera votre module Protracker: PlayMusic(1) Nous devons également définir quelle image serà la dernière. Dans notre exemple nous aurons 11 images s'échelonnant de "0.jpg" to "10.jpg" ainsi la dernière image est le nombre 10. Par conséquent nous ajoutons la ligne suivante à notre script: lastpic = 10 Nous ajoutons également la ligne suivante parce que notre première image est 0.jpg: pic = 0 7) La prochaine commande chargerà la prochaine illustration et l'affichera. Comme il n'y a aucune commande qui fait tout ceci, nous devons écrire cette fonction. Ce sous-programme s'appellera p_NextPic(). Vous verrez en 10 étapes comment écrire ce sous-programme. Imaginons que c'était déjà là et pour cette raison nous dirons maintenant que Hollywood exécutera ce sous-programme : p_NextPic () 8) Maintenant nous ajoutons la boucle principale à notre script. Le format populaire de cette boucle est la suivante: Repeat WaitEvent Forever La commande @{"WaitEvent()" LINK WaitEvent} maintient l'exécution du script jusqu'à se qu'un événement se produise, par exemple un bouton est appuyé. Si un événement se produit, WaitEvent() sautera à la fonction qui traite cet événement, par exemple si le bouton 1 est cliqueté, WaitEvent() sautera à la fonction p_Back(). Quand la fonction a terminé son action, elle saute en arrière dans notre boucle principale et WaitEvent() sera de nouveau appelé. Ceci est répété jusqu'à ce que l'utilisateur ferme 9) Maintenant la structure de notre script est complète. Ce que nous devons toujours faire maintenant c'est d'ajouté la fonction p_Back(), qui est appelé par WaitEvent() quand le bouton 1 (bouton en arrière) a été appuyé et p_Forward(), qui est appelé par WaitEvent() quand le bouton 2 (bouton avant) a été appuyé. Il est important que vous définissiez les fonctions avant de les mettre en référence. Vous devez ajouter le code suivant avant les appels à MakeButton() que vous avez ajouté dans l'étape 5. Donc ajouter ces fonctions pour les boutons maintenant: Function p_Back() If pic =0 pic = lastpic Else pic = pic - 1 EndIf p_NextPic() EndFunction Function p_Forward() If pic = lastpic pic = 0 Else pic = pic + 1 EndIf p_NextPic() EndFunction Comme vous pouvez le voir dans le code ci-dessus, la variable pic contient le vrai numéro de l'image. Si l'utilisateur clique sur le bouton avant, pic sera incrémenté de un, si le bouton en arrière est cliqueté elle est diminuée de un. La variable est également vérifiée entre 0 et lastpic de sorte qu'elle reste toujours dans la gamme de nos images. 10) Maintenant la seule chose à faire est notre fonction p_NextPic() qui charge et affiche l'image avec le numéro qui est enregistré dans la variable pic. Voici le code. Insérer ce code avant d'appeler MakeButton(). Function p_NextPic() LoadBrush(1, pic .. ".jpg") DisplayBrush(1, 29, 41) EndFunction Mais que fait le sous-programme p_NextPic? Il ajoute simplement un ".jpg" à la variable pic et charge le fichier et affiche la brosse aux coordonnées 29:41. Ainsi les images doivent être nommées comme ceci "0.jpg" (première image), "1.jpg" (deuxième image), "2.jpg" (troisième image) et ainsi de suite. Maintenant notre script ressemble à sa: @BGPIC 1, "BG.iff" @MUSIC 1, "MyMusic.mod" Function p_NextPic() LoadBrush(1, pic .. ".jpg") DisplayBrush(1, 29, 41) EndFunction Function p_Back() If pic =0 pic = lastpic Else pic = pic - 1 EndIf p_NextPic() EndFunction Function p_Forward() If pic = lastpic pic = 0 Else pic = pic + 1 EndIf p_NextPic() EndFunction MakeButton(1, #SIMPLEBUTTON, 4, 430, 35, 19, {OnMouseUp = p_Back}) MakeButton(2, #SIMPLEBUTTON, 591, 430, 35, 19, {OnMouseUp = p_Forward}) PlayMusic(1) lastpic = 10 pic = 0 p_NextPic() Repeat WaitEvent Forever Maintenant vous pouvez sauvegarder votre script et l'exécuter via l'interface graphique de Hollywood ou de la console. Félicitations, vous venez de créer votre premier script Hollywood. Se n'était pas si difficile? Seulement 35 lignes de code. Maintenant vous pouvez l'optimiser si vous le voulez. Par exemple, si vous voulez que l'image soit affichée avec un effet de transition, changer juste la ligne DisplayBrush(1,29,41) par DisplayBrushFX(1,29,41,#RANDOMEFFECT,10). @ENDNODE @NODE V6PrgG2KTiming "Guide Hollywood" @{b}Mécanisme de synchronisation de script@{ub} Le calage correct est un enjeu crucial pour chaque script qui doit être en mesure de fonctionner sur d'autres systèmes. Comme Hollywood est disponible pour plusieurs plates-formes, vous devez penser au calage de script si vous planifiez de distribuer votre script. Le problème fondamental est que si vous n'ajoutez pas une limite de vitesse à votre script, il fonctionnera aussi rapidement que l'ordinateur le permet. Ce n'est peut être pas être un problème sur votre système mais sur une machine plus puissante votre script risque d'être trop rapide. Imaginer que vous créez un jeu et que vous utilisez la boucle suivante: /*Mauvais code*/ While quit = False dir = p_QueryInput() If dir = "Gauche" Then p_MoveSpriteLeft() If dir = "Droite" Then p_MoveSpriteRight() etc. p_RedrawDisplay() Wend Les boucles comme celle-ci ont deux désavantages majeurs: 1) Il n'y a aucun calage dans cette boucle. Cette boucle fonctionnera toujours aussi rapidement que La CPU du système le permet. C'est réellement mauvais. Cela signifie que le calage sera seulement correct sur votre système et pas sur d'autres plus rapide. 2) Cette boucle utilisera 100% de votre puissance CPU parce qu'il n'y a aucune limite qui lui dit par exemple "d'exécuter cette boucle 25 fois par seconde!". L'utilisation de 100% de la puissance CPU n'est pas forcément un problème sur 68k mais si vous exécutez le script sur un système plus récent, l'OS ralentira sensiblement et le ventilateur du processeur pourraient s'emballer du à l'utilisation intensive du CPU. De plus, rappelez-vous que Hollywood fonctionne dans un environnement multitâche. Donc, en utilisant des boucles comme celle-ci les autres tâches auront moins de temps processeur. La solution à se problème est assez simple: devez juste indiquer à Hollywood d'exécuter cette boucle seulement un certain nombre de fois par seconde. Pour la plupart des jeux, 25 fois par seconde est suffisant. Il y a deux méthodes d'application de limiteur de temps: 1) En utilisant @{"WaitTimer()" LINK WaitTimer}. Cette commande accepte un chronomètre et une valeur de dépassement de durée. Il met le script en pause jusqu'à ce que le temps spécifié soit atteind. Alors le chronomètre sera initialisé pour être utiliser de nouveau. Notre boucle ci-dessus ressemblerait à celle-ci qui utilise WaitTimer() : /* Code correcte */ StartTimer(1) ; démarrer le chronomètre #1 While quit = False dir = p_QueryInput() If dir = "Gauche" Then p_MoveSpriteLeft() If dir = "Droite" Then p_MoveSpriteRight() etc. p_RedrawDisplay() WaitTimer(1, 40) ; ne pas fonctionner plus rapidement que 40 millisecondes Wend Notre boucle ne pourra fonctionner plus rapidement que 40 millisecondes. Ainsi elle ne sera jamais exécutée plus rapidement que 25 fois par seconde puisque 25 * 40 = 1000. Donc, un jeu utilisant cette boucle fonctionnera à la même vitesse sur tous les systèmes - aucune différence entre le CPU a 50mhz ou 1ghz. 2) La deuxième méthode est @{"SetInterval()" LINK SetInterval}. Cette commande vous permet d'installer une commande d'intervalle qu'Hollywood exécutera le script à la fréquence spécifié. Ainsi, vous pouvez indiquer à Hollywood d'exécuter votre boucle de jeu 25 fois par seconde. le code ressemblerait à se qui suit: /* Code correcte */ Function p_MainLoop() ; c'est le même code que dans le notre boucle Function p_MainLoop() ci-dessus dir = QueryInput() If dir = "Gauche" Then MoveSpriteLeft() If dir = "Droite" Then MoveSpriteRight() etc. RedrawDisplay() EndFunction ; exécute la fonction MainLoop () 25 fois par seconde -> 40 * 25 = 1000 millisecondes SetInterval(1, p_MainLoop, 40) While quit = False WaitEvent Wend Ce code effectue la même chose que le code au-dessus qui utilise WaitTimer(). La seule différence est que vous devez utiliser @{"WaitEvent()" LINK WaitEvent} avec SetInterval() parce que les commandes d'intervalle déclenchent des événements Hollywood. Les deux méthodes indiqués ci-dessus sont faciles à utiliser et effectives. A vous à décider d'utiliser celui que vous préférez. @ENDNODE @NODE V6PrgG2KAnimation "Guide Hollywood" @{b}Techniques d'animation@{ub} Quand vous voulez utiliser des animations, vous devez choisir entre 2 techniques: Sprite et double buffer. Ce chapitre est conçu pour vous donner une synthèse des deux techniques de sorte que vous puissiez utiliser celle qui se réfère le mieux à vos besoins. 1. Sprites Les sprites sont particulièrement utiles quand il n'y a pas beaucoup de graphismes à affiché. Par exemple, si vous devez seulement déplacer certains blocs graphiques ou plusieurs sprites. Dans ce cas-ci, il vaut mieux d'utiliser des sprites parce que Hollywood peut régénérer l'affichage rapidement puisqu'il y a peu de changement à l'écran (moins de pixel à traiter). Pour plus d'information sur les sprites, lire @{"introduction au sprite" LINK SpritesIntroduction}. 2. Double buffer En utilisant un double buffer, Hollywood doit régénérer l'affichage en totalité (toutes les pixel de l'écran). Cette technique paut être utilisé sur un écran de 640x480 qui nécessite d'être affiché 25 fois par seconde. Donc, un double buffer est seulement recommandé quand beaucoup de graphismes doivent être affichés. Par exemple, les exemples Hollywood qui affiche un défilement d'image utilise un double buffer puisqu'ils est nécessaire de régénéré la totalité de l'écran ou tout du moins une grosse partie. De telles exemples ne peuvent être traité en utilisant la technique des sprites puisque les commandes d'affichage ou de traçage sont fortement personnalisés et change à chaque image. L'avantage de la technique du double buffer avec Hollywood est qu'Hollywood redimensionnera automatiquement votre double buffer si la fenêtre est redimensionnée. Pour plus d'information sur le doubles buffer, lire @{"BeginDoubleBuffer()" LINK BeginDoubleBuffer}. Voici quelques techniques d'animation que l'auteur de Hollywood utiliserait pour des applications: Jeux de carte: Sprites. Pas beaucoup d'action sur l'écran. Tetris : Des sprites parce qu'il n'y a pas beaucoup de régénération d'écran PacMan : Sprites. Les seuls éléments qui bougent sont les ennemis et le joueur. Shoot them up: Double buffer parce qu'il y à un scrolling. Par conséquent, il y a des différences majeurs entre les régénérations d'écran. Jump'n Run : Double buffer s'il y a un scrolling. Si il n'y à pas de scrolling alors la technique des sprites Démo : Double Buffer. C'est un cas classique de double buffer. @ENDNODE @NODE V6PrgG2KMaskAlpha "Guide Hollywood" @{b}Le masque et le canal alpha@{ub} Hollywood supporte deux types de transparence pour les objets graphiques: Le masque de transparence et la transparence alpha. Ce chapitre explique la différence entre ces deux techniques. Le masque de transparence n'a seulement que deux réglages par Pixel: Visible et invisible. La transparence alpha, supporte 256 niveaux de transparence différente pour chaque Pixel. Un niveau 0 signifie que le Pixel n'est pas visible, et un niveau de 255 signifie que le Pixel est visible. Un niveau de 128 signifie qu'un Pixel est seulement visible à 50%. La transparence alpha est très utile si vous voulez inclure des images qui s'adapte à votre fond d'écran. Par exemple, une brosse avec une ombre où le fond est visible au travers, ou une brosse avec les rebords lissés. Pour de tels méthodes, un masque n'est pas assez efficace. Noter également que le masque et le canal alpha sont mutuellement exclusivif. C'est-à-dire qu'une brosse ne peut pas avoir un masque et un canal alpha mais seulement l'un des deux. @ENDNODE @NODE V6PrgG2KTroubleshooting "Guide Hollywood" @{b}Problèmatique@{ub} Ce chapitre couvre quelques problèmes courants et présente leurs solutions. @{b}Initialisation de tableaux@{ub} Attention quand vous créez un tableau en y assignant une variable qui n'est pas utilisé, c.-à-d. Nil. Car l'indicateur du tableau ne sera pas créé. Par exemple, ce qui suit ne fonctionne pas : t = {} ; créer un tableau t.x = y ; affecter "y" à l'indicateur x ; noter que y est Nil DebugPrint (t.x) ; ---> erreur, car l'indicateur "x" n'est pas initialisé La solution est de l'initialiser avant, par Exemple: t = {} ; créer un tableau y = 0 ; régler y à 0 t.x = y ; affecter "y" à l'indicateur x DebugPrint (t.x) ; Fonctionne, et affiche " 0 " @{b}Vérifier si une variable est Nil@{ub} Attention en vérifiant une variable qui est Nil. Vérifier si une variable est Nil n'est pas une bonne idée parce que cela donnerait également comme résultat True si la variable est à zéro au lieu de Nil. Exemple: a = 0 b = Nil DebugPrint(GetType(a) = #NIL, a = Nil) ; affiche "0 1" DebugPrint(GetType(b) = #NIL, b = Nil) ; affiche "1 1" Vous remarquez que "a = Nil" renvoie True bien qu'il soit à zéro. C'est parce que Nil est toujours considéré comme égal à zéro une fois utilisé dans les expressions. Donc, si vous voulez connaître si une variable est réellement à Nil utiliser GetType() et il compara si le résultat correspond à #NIL. @{b}Initialization de variable@{ub} Dans Hollywood, l'initialisation de plusieurs variables est un peu différente que dans la plupart des autres langages puisque Hollywood attend seulement un signes d'égalité. Par exemple, ce qui suit est incorrect: ; Local a = 5, b = 6, c = 7 Malheureusement, ce code n'engendrerez aucune erreur mais une mauvaise interprétation. le code ci-dessus demande à Hollywood d'affecter 5 à a et n'enregistre pas la suite parce qu'il y a seulement une variable sur le côté gauche des signes d'égalité. Donc vous devez faire attention avec plusieurs variable à initialiser. Donc, le code correcte serait le code suivant: ;code correcte Local a, b, c = 5, 6, 7 Ce code affectera 5 à a, 6 à b, et 7 à C. @{b}Valeurs de renvoie@{ub} Prendre soin avec les commandes qui retourne une information. La valeur de renvoi doit être indiqué entre parenthèses. Coder comme ceci est une mauvaise méthode et ne déclenche pas d'erreur: Function p_Add(a, b) Local r = a + b Return r ; Aïe!!! EndFunction Ce code serait interprété comme ceci "renvoi, et appelle de la fonction r()". Naturellement, l'appel à r() ne sera jamais atteint mais la fonction écrite au-dessus retournera Nil, c.-à-d. rien, dans tous les cas. Le code correcte est celui-ci: Function p_Add(a, b) Local r = a + b Return(r) EndFunction @ENDNODE @NODE V6PrgG2KIntro "Guide Hollywood" @{b}Bon à savoir@{ub} Ce chapitre contient quelques informations complémentaires sur divers sujets importants. @{"Mécanisme de synchronisation de script " LINK V6PrgG2KTiming} sujet très important. A lire. @{"Techniques d'animation " LINK V6PrgG2KAnimation} trouver la meilleure technique d'animation pour vos projets @{"Le masque et le canal alpha " LINK V6PrgG2KMaskAlpha} où est la différence entre les deux ? @{"Problèmatique " LINK V6PrgG2KTroubleshooting} Attention aux erreurs @{"Tutoriel " LINK V6PrgG2KTutorial} votre présentation Hollywood en 10 opérations faciles @ENDNODE @NODE RGBInfo "Guide Hollywood" @{b}Information sur la couleur RGB@{ub} Hollywood accepte les couleurs dans le formats RGB 24-bit. Ceci signifie que vous avez 8 bits par couleur. RGB24 est le format courant pour spécifier les couleurs par exemple il est utilisé dans le HTML. Vous spécifierez habituellement les couleurs RGB dans une notation hexadécimale qui commence par un préfixe "$". La syntaxe générale pour une couleur RGB dans la notation hexadécimale est $RRGGBB RR : intensité de la couleur rouge (maximum = 255 = $FF = 100% rouge) GG : intensité de la couleur verte (maximum = 255 = $FF = 100% vert) BB : intensité de la couleur bleu (maximum = 255 = $FF = 100% bleu) Les couleurs sont créer en mélangeant le rouge, le vert et le bleu. Chaque composante de couleur peut avoir une valeur maximum de 255. Voici quelques couleurs en exemple: #BLACK = $000000 - le noir, c'est 0% de chaque composante #WHITE = $FFFFFF - le blanc, c'est 100% de chaque composante #RED = $FF0000 - le rouge vif, c'est 100% du rouge #GREEN = $00FF00 - 100% du vert #BLUE = $0000FF - 100% du bleu #YELLOW = $FFFF00 - le jaune est un mélange de 100% rouge et vert #MAGENTA = $FF00FF - le magenta,c'est 100% de rouge et de bleu #GRAY = $939393 - le gris est une partie égale de toute les composantes Quand Hollywood vous demande une couleur RGB, vous pouvez spécifier votre couleur en utilisant la notation hexadécimale ou également une des constantes spéciales incorporées de couleur. Cliquer @{"ici" LINK "Tutorial/Colors.iff/MAIN"} pour voir une synthèse de ces couleurs. @ENDNODE @NODE FilterTable "Guide Hollywood" @{b}Information sur le tableau de filtre@{ub} Depuis Hollywood 4.0, quelques commandes reçoivent un tableau de filtre en tant que dernier argument optionnel. Par Exemple: @{"DisplayBrush()" LINK DisplayBrush}, @{"PlayAnim()" LINK PlayAnim}, et @{"DisplayAnimFrame()" LINK DisplayAnimFrame}. Ce tableau peut contenir un ou plusieurs filtres qui peuvent être appliqués aux objets graphiques avant qu'ils soient affichés. Les filtres suivants sont disponibles: Width Height : si vous spécifiez ces éléments de filtres, l'objet sera redimensionné selon ces dimensions et affiché. Rotate : Cet élément de filtre affichera l'objet avec l'angle de rotation spécifié. SmoothScale : Si il est réglé avec TRUE, le redimensionnement et/ou la rotation seront effectué en utilisant l'interpolation anti-aliasing. Noter que si vous utilisez le tableau de filtre, les caractéristiques des objets graphiques ne seront jamais modifiés. Si vous voulez redimensionner ou orienter un objet de façon permanente, vous devez utiliser @{"ScaleBrush()" LINK ScaleBrush}/@{"RotateBrush()" LINK RotateBrush} pour les brosses ou les commandes appropriés pour les autres types d'objets. Si les calques sont ativés, les filtres spécifiés seront immédiatement appliqués au nouveau calque en utilisant @{"SetLayerStyle()" LINK SetLayerStyle}. Les deux parties de code suivants faire la même chose sauf que le calque (1) sera brièvement visible dans ses tailles d'origine avant d'être réduit: (1) EnableLayers DisplayBrush(1, 0, 0) SetLayerStyle(1, {Width = 100, Height = 75}) (2) EnableLayers DisplayBrush(1, 0, 0, {Width = 100, Height = 75}) @ENDNODE @NODE ARGBInfo "Guide Hollywood" @{b}Information sur les couleurs ARGB@{ub} Une couleur ARGB est une @{"couleur RGB" LINK RGBInfo} améliorer avec une information de transparence alpha. Cette notation est utile pour les commandes de la @{"bibliothèque de traçage" LINK V6LibGfxDraw} parce qu'elles vous permettent de spécifier une couleur ARGB. Par conséquent, vous pouvez dessiner les primitives graphiques avec un effet de transparence. Une couleur normale RGB est en 24-bit alors qu'une couleur ARGB utilise 32 bits. Les 8 bits les plus élevés sont utilisés pour information de transparence alpha qui peut s'échelonner de 0 à 255. Ainsi, une couleur ARGB ressemble à ce qui suit $AARRGGBB Une valeur alpha de 0 signifie qu'il n'y a aucune transparence. La valeur de transparence totale est de 255. C'est une inversion du format utilisé dans @{"SetAlphaIntensity()" LINK SetAlphaIntensity} où 255 est sans transparence et 0% est 100% transparent. Noter que vous pouvez utiliser la commande @{"ARGB()" LINK ARGB} pour combiner facilement une valeur de transparence alpha avec des couleurs RGB 24-bit. @ENDNODE @NODE AutoIDSelect "Guide Hollywood" @{b}Sélection automatique d'identificateur@{ub} Vous pouvez indiquer @{"Nil" LINK V6PrgTypeNil} à toutes les commandes qui demande de spécifier une identification vide pour un nouvel objet Hollywood. Dans ce cas, Hollywood choisira automatiquement une identification vide et la retournera. C'est utile pour de grand projets. Si votre projet est petit il est plus facile d'utiliser des ids définie par vous même , par exemple. LoadBrush(1, "brush1.iff") LoadBrush(2, "brush2.iff") LoadSample(1, "sample.wav") OpenFile(1, "file.txt") Cependant, si votre projet s'agrandi, le management d'identification peut devenir difficile et personne n'a envie forcément de gérer une multitude d'ids différents. Donc, vous pouvez simplement indiquer @{"Nil" LINK V6PrgTypeNil} au lieu d'une identification et Hollywood retournera une identification pour votre nouvel objet qui est garanti unique parce qu'il utilise le type de variable spéciale #LIGHTUSERDATA. De cette façon, il est assuré qu'aucun conflit d'identification ne surviendra parce que si vous indiquez @{"Nil" LINK V6PrgTypeNil}, Hollywood ne choisira pas une identification du gisement d'identification (c.-à-d. les nombres entier de 1 à n) mais il créera des identificateurs uniques. Ainsi, tous les ids normal seront toujours disponible pour une utilisation, par exemple. brush1 = LoadBrush(Nil, "brush1.iff") brush2 = LoadBrush(Nil, "brush2.iff") sample1 = LoadSample(Nil, "sample.wav") file1 = OpenFile(Nil, "file.txt") Les variables brush1, brush2, sample1, et file1 ne recevront pas d'ids fourni par le programmeur mais des ids spéciaux de type #LIGHTUSERDATA. Ainsi, tous les ids lisibles par l'utilisateur de 1 à n seront toujours disponibles. Par conséquent vous ne devez pas vous inquiéter des conflits d'identifications en indiquant @{"Nil" LINK V6PrgTypeNil} à la fonction de création d'objet puisque Hollywood utilise deux dimensions d'ids l'une lisible puisque c'est vous qui indiquez une identification à la fonction de création d'objet et un mécanisme interne d'identification qui est utilisé quand vous indiquez @{"Nil" LINK V6PrgTypeNil} dans la fonction de création d'objet. @ENDNODE @NODE CONSTANT "Guide Hollywood" @{APEN 4}@{B}MOTS CLE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} CONSTANT -- déclarer une constante (V1.5) @{b}SYNOPSIS@{ub} %CONSTANT() = name$ / val @{b}NOTE IMPORTANT@{ub} Ce mot clé est @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1}. Utiliser @{"Const" LINK V6PrgConst}. @{b}FONCTION@{ub} Ce mot clé vous permet de déclarer vos propres constantes. Indiquer le nom désiré de la constante dans @{b}name$@{ub} et sa valeur dans @{b}val@{ub} et la constante sera ajoutée dans la liste interne d'Hollywood. Vous pouvez également déclarer des constantes en utilisant la déclaration @{"Const" LINK V6PrgConst}. Cette déclaration vous permet d'utiliser des expressions alors que la valeur a spécifié ici doit être une valeur unique. Depuis la V2.0 : "val" peut également être une chaîne ou un nombre à virgule flottante. @{b}INPUTS@{ub} name$ - nom désiré pour la constante; ne pas oublier les guillemets val - la valeur à la laquelle on initialiserà la constante @{b}EXEMPLE@{ub} %CONSTANT = "#TESTCONST" / 10 %CODE Print(#TESTCONST) Le code ci-dessus affichera "10" à l'écran. @ENDNODE @NODE CODE "Guide Hollywood" @{APEN 4}@{B}MOTS CLE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} CODE -- déclarer la fin de la section de mots clés @{b}SYNOPSIS@{ub} %CODE() @{b}NOTE IMPORTANT@{ub} Ce mot clé est @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1}. Depuis Hollywood 2.0 le script n'est plus divisé entre l'en-tête et la section de code. @{b}FONCTION@{ub} C'est le mot clé primordiale que vous devez utiliser dans tous vos scripts. Il marque l'extrémité de la section de mots clés (la fin de l'en-tête de votre script) et en même temps elle marque le début de votre code. Après ce mot clé vous pouvez commencer à utiliser les commandes mais vous ne pouvez plus utiliser de mots clés. @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} %BGPIC(1)="MyBG.iff" %CODE Print("hé ! Nous avons atteint Le code réel maintenant!") WaitLeftMouse @ENDNODE @NODE HOLLYWOOD "Guide Hollywood" @{APEN 4}@{B}MOTS CLE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} HOLLYWOOD -- définir quelle version d'Hollywood est exigé pour votre script @{b}SYNOPSIS@{ub} %HOLLYWOOD()=version/revision @{b}NOTE IMPORTANT@{ub} Ce mot clé est @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1}. Utiliser @{"@VERSION" LINK atVERSION}. @{b}FONCTION@{ub} Ce mot clé définit la version minimum d'Hollywood compatible avec votre script. Vous devez toujours utiliser ce mot clé en premier dans votre en-tête de script. @{b}INPUTS@{ub} version - numéro de version revision - numéro de mise à jour @{b}EXEMPLE@{ub} %HOLLYWOOD=1/0 Définit que ce script exige au moins Hollywood 1.0. @ENDNODE @NODE BUTTON "Guide Hollywood" @{APEN 4}@{B}MOTS CLE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} BUTTON -- déclarer un bouton @{b}SYNOPSIS@{ub} %BUTTON(number)=x1/y1/x2/y2 @{b}NOTE IMPORTANT@{ub} Ce mot clé est @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1}. Utiliser @{"MakeButton()" LINK MakeButton}. @{b}FONCTION@{ub} Attention : Cette commande fait partie de la bibliothèque d'événement de Hollywood 1.x. Vous ne devait pas l'utiliser sur les version supérieurs. Utiliser @{"MakeButton()" LINK MakeButton}. Utiliser ce mot clé pour déclarer un bouton sur votre écran. Le bouton est défini par les coordonnées @{b}x1@{ub}:@{b}y1@{ub} à @{b}x2@{ub}:@{b}y2@{ub}. Si l'utilisateur déplace la souris au-dessus du bouton ou clique sur se même bouton, Hollywood exécutera un saut avec Gosub() au label nommé ONBUTTONOVER et le numéro du bouton spécifié par @{b}number@{ub}. @{b}INPUTS@{ub} x1 - rebord gauche source y1 - premier rebord source x2 - bon rebord destination y2 - rebord inférieur destination @{b}EXEMPLE@{ub} %BUTTON(1)=0/0/200/200 %BUTTON(2)=201/0/400/200 %KEYDOWN(1)="ESC" %CODE While(quit=FALSE) WaitEvent Wend End Label(ONBUTTONOVER1) Print("souris au-dessus de bouton 1") WhileMouseOn Print("souris hors de bouton 1") Return Label(ONBUTTONCLICK1) Print("bouton 1 cliqué par utilisateur") WhileMouseDown Print("bouton de la souris gauche relché par utilisateur") Label(ONBUTTONRIGHTCLICK1) ; exige Hollywood 1.5 Print("L'utilisateur a fait un clic droit sur le bouton 1") WhileRightMouseDown Print("bouton de la souris droit relché par l'utilisateur") Return Label(ONBUTTONOVER2) Print("souris au-dessus de bouton 2") WhileMouseOn Print("souris hors de bouton 2") Return Label(ONBUTTONCLICK2) Print("bouton 2 cliqué par l'utilisateur") WhileMouseDown Print(" bouton de la souris gauche relché par l'utilisateur") Return Label(ONBUTTONRIGHTCLICK2) Print("L'utilisateur a fait un clic droit sur le bouton 2"); exige Hollywood 1.5 WhileRightMouseDown Print(" bouton de la souris droit relché par l'utilisateur") Label(ONKEYDOWN1) quit=TRUE Return Le code ci-dessus créé deux boutons sur l'écran et contrôle l'activité de l'utilisateur. Si il presse la touche ESC, se programme s'arretera. Cet exemple montre une bonne méthode pour traiter les actions de l'utilisateur: Il est conseillé d'utilisez une boucle comme While(quit=FALSE) WaitEvent Wend pour traiter les actions de l'utilisateur. Attention, vous devez vous assurer que la commande WaitEvent() est dans la boucle. @ENDNODE @NODE KEYDOWN "Guide Hollywood" @{APEN 4}@{B}MOTS CLE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} KEYDOWN -- déclarer une touche @{b}SYNOPSIS@{ub} %KEYDOWN(number)=key$ @{b}NOTE IMPORTANT@{ub} Ce mot clé est @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1}. @{b}FONCTION@{ub} Attention: Cette commande fait partie de la bibliothèque d'événement de Hollywood 1.x. Vous ne devait plus l'utiliser dans les versions supérieur. Veuillez utiliser les commandes de la nouvelle bibliothèque d'Hollywood 2.0 qui sont optimisé. Utiliser ce mot clé pour déclarer une touche à contrôler. Si l'utilisateur presse cette touche, Hollywood exécutera un saut avec Gosub() au label appelée ONKEYDOWN avec le numéro d'identification spécifié dans @{b}number@{ub}. Key$ est une chaîne représentant une touche sur votre clavier. Celle-ci peut être une de ces touches de commande suivantes : @{APEN 1}"UP" - curseur vers le haut @{APEN 9}"DOWN" - curseur vers le bas @{APEN 1}"RIGHT" - curseur vers la droite @{APEN 9}"LEFT" - curseur vers la gauche @{APEN 1}"HELP" - Touche Help @{APEN 9}"DEL" - Touche DEL @{APEN 1}"BACKSPACE" - touche backspace @{APEN 9}"TAB" - touche TAB @{APEN 1}"RETURN" - touche entrée/return @{APEN 9}"ESC" - touche echap @{APEN 1}"SPACE" - barre d'espace @{APEN 9}"F1 - F10" - touche fonction @{APEN 1} Les autres touches peuvent être consultées en spécifiant juste le caractère de la touche dans la chaîne, par exemple "A", "!" ou "-". Les touches suivantes ne peuvent pas être contrôlées: ALT, les touches de commande et la touche control. @{b}INPUTS@{ub} key$ - touche à contrôler @{b}EXEMPLE@{ub} %KEYDOWN(1)="ESC" %CODE While(quit=FALSE) WaitEvent Wend End Label(ONKEYDOWN1) quit=TRUE Return Le code ci-dessus attend que l'utilisateur presse la touche ESC. Alors il s'arrêtera. Une structure de code comme ci-dessus est recommandée pour vos applications. @ENDNODE @NODE DISPLAYCOLOR "Guide Hollywood" @{APEN 4}@{B}MOTS CLE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} DISPLAYCOLOR -- définir la couleur pour le fond d'écran initial (V1.5) @{b}SYNOPSIS@{ub} %DISPLAYCOLOR() = col @{b}NOTE IMPORTANT@{ub} Ce mot clé est @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1}. utiliser @{"@DISPLAY" LINK atDISPLAY}. @{b}FONCTION@{ub} L'utilisation de ce mot clé est seulement nécessaire si vous ne spécifiez pas d'image de fond et si vous voulez que la couleur d'arrière plan de votre écran soit différente du noir. Spécifier ce mot clé avec votre couleur désiré et votre écran initial aura cette couleur d'arrière plan. @{b}INPUTS@{ub} col - couleur d'arrière plan désirée @{b}EXEMPLE@{ub} %DISPLAYSIZE = 320/240 %DISPLAYCOLOR = $FF0000 Le code ci-dessus ouvre un écran 320x240 avec une couleur de fond rouge. @ENDNODE @NODE DISPLAYDESKTOP "Guide Hollywood" @{APEN 4}@{B}MOTS CLE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} DISPLAYDESKTOP -- utiliser l'écran de bureau comme image de fond (V1.5) @{b}SYNOPSIS@{ub} %DISPLAYDESKTOP() @{b}NOTE IMPORTANT@{ub} Ce mot clé est @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1}. Utiliser @{"@DISPLAY" LINK atDISPLAY}. @{b}FONCTION@{ub} Si ce mot clé est spécifié, l'image initiale de fond sera une copie de votre écran de bureau (WorkBench). Ceci peut être utilisé pour créer quelques effets sympathique. Votre écran aura la même taille que l'écran de bureau et Hollywood ouvrira une fenêtre sans bord. @{b}INPUTS@{ub} aucun @ENDNODE @NODE DISPLAYSIZE "Guide Hollywood" @{APEN 4}@{B}MOTS CLE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} DISPLAYSIZE -- définir les dimensions pour la taille initiale de l'écran @{b}SYNOPSIS@{ub} %DISPLAYSIZE()=width/height @{b}NOTE IMPORTANT@{ub} Ce mot clé est @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1}. Utiliser @{"@DISPLAY" LINK atDISPLAY}. @{b}FONCTION@{ub} L'utilisation de ce mot clé est seulement nécessaire si vous ne spécifiez pas une image de fond et que vous voulez utiliser des dimensions d'écran différente que la taille par défaut (640x480). Régler donc ce mot clé avec les dimensions désirées et Hollywood ouvrira cet écran dans la résolution demandée. @{b}INPUTS@{ub} width - largeur désirée height - hauteur désirée @{b}EXEMPLE@{ub} %DISPLAYSIZE = 320/240 %CODE Print("Hello World") WaitLeftMouse End Le code ci-dessus ouvre un écran de 320x240 et affiche "Hello World", il attend que l'utilisateur clic sur le bouton gauche de la souris et s'arrête. @ENDNODE @NODE TITLE "Guide Hollywood" @{APEN 4}@{B}MOTS CLE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} TITRE -- déclarer le titre de votre application @{b}SYNOPSIS@{ub} %TITLE()=title$ @{b}NOTE IMPORTANT@{ub} Ce mot clé est @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1}. Utiliser @{"@DISPLAY" LINK atDISPLAY}. @{b}FONCTION@{ub} Vous pouvez utiliser ce mot clé pour donner un titre à votre application. Ce titre sera affiché dans la barre de fenêtre Hollywood (si là fenêtre a des bords) et dans la barre de titre de l'écran (seulement si Hollywood ouvre un écran et que la barre est affiché). @{b}INPUTS@{ub} title$ - titre de votre application @{b}EXEMPLE@{ub} %TITLE= " ma présentation " Le code ci-dessus déclare " ma présentation " comme titre d'application. @ENDNODE @NODE BRUSH "Guide Hollywood" @{APEN 4}@{B}MOTS CLE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} BRUSH-- précharger une brosse (brush) pour un usage ultérieur @{b}SYNOPSIS@{ub} %BRUSH(number)=[TRANSPARENTCOLOR/color/]Filename$ @{b}NOTE IMPORTANT@{ub} Ce mot clé est @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1}. Utiliser @{"@BRUSH" LINK atBRUSH}. @{b}FONCTION@{ub} utiliser ce mot clé pour déclarer une brosse que vous voulez préchargé pour un usage ultérieur dans votre code. La brosse sera chargé par l'intermédiaire des datatypes. La transparence pour les brosses est également supportée. Spécifier juste une @{"valeur RGB" LINK RGBInfo} pour que la couleur et votre brosse soient transparentes. Si vous êtes limité en mémoire et que vous voulez charger des brosses manuellement, utiliser la commande @{"LoadBrush()" LINK LoadBrush}. @{b}INPUTS@{ub} number - une valeur qui est utilisée pour identifier la brosse plus tard dans le code color - optionnel: vous pouvez faire apparaître les brosses d'une manière transparente si vous spécifiez une couleur ici filename$ - le fichier image que vous voulez utiliser @{b}EXEMPLE@{ub} %BRUSH(1)="dh0:MyBrush.iff" Déclarent " dh0 :MyBrush.iff " en tant que brush 1 sans la transparence. ------------------------------------ %BRUSH(1)=TRANSPARENTCOLOR/$FF0000/"dh0:MyBrush.iff" Fait la même chose comme ci-dessus mais la brosse (brush) est maintenant transparente (la couleur de transparence est le rouge=$FF0000). @ENDNODE @NODE BGPIC "Guide Hollywood" @{APEN 4}@{B}MOTS CLE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} BGPIC -- précharger une image de fond pour un usage ultérieur @{b}SYNOPSIS@{ub} %BGPIC(number)=[TRANSPARENTCOLOR/color/]Filename$ @{b}NOTE IMPORTANT@{ub} Ce mot clé est @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1}. Utiliser @{"@BGPIC" LINK atBGPIC}. @{b}FONCTION@{ub} Utiliser ce mot clé pour déclarer une image de fond que vous voulez préchargé pour un usage ultérieur dans votre code. L'image sera chargé par l'intermédiaire des datatypes. La transparence pour des images de fond est supporté. Spécifier juste une @{"valeur RGB" LINK RGBInfo} comme couleur et votre image sera transparente. Si vous spécifiez 1 comme @{b}number@{ub}, alors cette image sera utilisé comme image de fond initiale quand Hollywood ouvrira votre écran. Si vous êtes limité en mémoire et que vous voulez charger des images de fond manuellement, utiliser la commande @{"LoadBGPic()" LINK LoadBGPic}. @{b}INPUTS@{ub} number - une valeur qui est utilisée pour identifier cette image de fond plus tard dans Le code; si @{b}number@{ub} est 1 alors cette image sera l'image de fond initial color - optionnel: vous pouvez faire que cette image de fond apparaisse d'une manière transparente si vous spécifiez une couleur ici filename$ - le fichier image que vous voulez utiliser @{b}EXEMPLE@{ub} %BGPIC(1)="dh0:MyBG.iff" Déclarent "dh0 :MyBG.iff" comme image de fond initiale (sera affiché quand Hollywood démarrera). %BGPIC(1)=TRANSPARENTCOLOR/$FF0000/"dh0:MyBG.iff" Fait la même chose que ci-dessus mais l'image est maintenant transparente (la couleur de transparence est le rouge=$FF0000). @ENDNODE @NODE SAMPLE "Guide Hollywood" @{APEN 4}@{B}MOTS CLE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} SAMPLE -- précharger un échantillon sonore pour un usage ultérieur @{b}SYNOPSIS@{ub} %SAMPLE(number)=Filename$ @{b}NOTE IMPORTANT@{ub} Ce mot clé est @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1}. Utiliser @{"@SAMPLE" LINK atSAMPLE}. @{b}FONCTION@{ub} Utiliser ce mot clé pour déclarer un fichier son que vous voulez préchargé pour le jouer plus tard en utilisant @{"PlaySample()" LINK PlaySample}). L'échantillon peut être dans n'importe quel format du moment que vous avez les bons datatypes. Si vous êtes limité en mémoire et que vous voulez charger l'échantillon manuellement, utiliser la commande @{"LoadSample()" LINK LoadSample}. @{b}INPUTS@{ub} number - une valeur qui est utilisée pour identifier cet échantillon plus tard dans le code filename$ - l'échantillon sonore que vous voulez charger @{b}EXEMPLE@{ub} %SAMPLE(1)="dh0:Sound/Samples/Gunshot.8svx" La déclaration ci-dessus affecte l'échantillon numéro 5 à l'échantillon: "dh0:Sound/Samples/Gunshot.8svx". @ENDNODE @NODE MODULE "Guide Hollywood" @{APEN 4}@{B}MOTS CLE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} MODULE -- précharger un module de musique pour un usage ultérieur @{b}SYNOPSIS@{ub} %MODULE(number)=Filename$ @{b}NOTE IMPORTANT@{ub} Ce mot clé est @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1}. Utiliser @{"@MUSIC" LINK atMUSIC}. @{b}FONCTION@{ub} Utiliser ce mot clé pour déclarer un fichier module de musique que vous voulez jouer plus tard dans votre code (en utilisant @{"PlayModule()" LINK PlayModule}). Le fichier sera préchargé et pour cette raison il est prêt pour un usage immédiat quand l'exécution de votre script commence. Si vous êtes limité en mémoire et que vous voulez charger le module manuellement dans votre code, vous pouvez utiliser la commande @{"LoadModule()" LINK LoadModule}. Filename$ est une chaîne indiquant un module de musique qui doit être au Format Protracker. @{b}INPUTS@{ub} number - une valeur qui est utilisée pour identifier ce module plus tard dans le code filename$ - le module de musique que vous voulez charger @{b}EXEMPLE@{ub} %MODULE(5)="dh0:Sound/Modules/StardustMemories.mod" La déclaration ci-dessus affecte le numéro de module 5 au module: "dh0:Sound/Modules/StardustMemories.mod". @ENDNODE @NODE ANIM "Guide Hollywood" @{APEN 4}@{B}MOTS CLE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} ANIM -- précharger une animation pour un usage ultérieur @{b}SYNOPSIS@{ub} %ANIM(number)=[TRANSPARENTCOLOR/color/]Filename$ @{b}NOTE IMPORTANT@{ub} Ce mot clé est @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1}. Utiliser @{"@ANIM" LINK atANIM}. @{b}FONCTION@{ub} Utiliser ce mot clé pour déclarer une animation que vous voulez préchargé pour un usage ultérieur dans votre code. L'animation sera chargée par l'intermédiaire des datatypes. La transparence pour des animations est également supportée. Spécifier juste une @{"valeur RGB" LINK RGBInfo} pour que la couleur et votre animation soient transparentes. Note: Hollywood chargera l'animation complète dans la mémoire afin de vous offrir une vitesse de lecture parfaite. Toutes les opérations de remapping seront effectuées pendant le chargement, ainsi la lecture est très rapide mais vous aurez besoin évidemment de beaucoup de mémoire. Mais ce ne devrait pas être un problème de nos jours (sûrement pas sur les systèmes RTG). Cependant, si vous êtes limité en mémoire, vous pouvez également charger et libérer des animations pendant l'exécution de script par l'utilisation des commandes @{"LoadAnim()" LINK LoadAnim} et @{"FreeAnim()" LINK FreeAnim}. Si cela ne fonctionne pas non plus, vous pouvez utiliser la commande @{"PlayAnimDisk()" LINK PlayAnimDisk} qui jouera l'animation directement du disque dur mais se n'est pas fluide et rapide sur les systèmes 68k. @{b}INPUTS@{ub} number - une valeur qui est utilisée pour identifier cette animation plus tard dans le code couleur - optionnel: vous pouvez faire apparaître cette animation d'une manière transparente si vous spécifiez une couleur ici filename$ - le fichier d'animation que vous voulez utiliser @{b}EXEMPLE@{ub} %ANIM(1)="dh0:MyAnim.iff" Déclarent " dh0 :MyAnim.iff " comme animation 1 sans la transparence. %ANIM(1)=TRANSPARENTCOLOR/$FF0000/"dh0:MyAnim.iff" Fait la même chose que ci-dessus mais l'animation est maintenant transparente (la couleur de transparence est le rouge=$FF0000). @ENDNODE @NODE atDISPLAY "Guide Hollywood" @{b}NOM@{ub} DISPLAY -- définir les attributs d'écran (V2.0) @{b}SYNOPSIS@{ub} @DISPLAY table @{b}FONCTION@{ub} Cette commande préprocesseur vous permet de définir les réglages de votre écran initial qu'Hollywood à besoin de connaître avant l'exécution du script. C'est pourquoi @DISPLAY est implémenté comme commande préprocesseur. @DISPLAY contient un tableau qui peut contenir les arguments suivants: Title : Vous pouvez utiliser cet item pour donner un titre à votre application. Ce titre sera affiché dans le bar de fenêtre Hollywood (si la fenêtre a des bords) et dans le bar de titre de l'écran (si Hollywood est ouvert sur son propre écran et que la bar est visible). X, Y : Ces deux paramètres permettent de définir la taille d'écran qui doit s'ouvrir. En utilisant ces valeurs ici est plutôt contre-productif puisque la plupart du temps vous ne connaissez pas la taille d'écran dans laquelle votre fenêtre sera ouverte (à moins que vous utilisiez le mode pleine écran). Il est bien plus judicieux et prudent d'utiliser les @{"constantes spéciale de coordonnées" LINK V6PrgInbuiltCst}. Si vous n'utiliser pas ces arguments, l'affichage sera toujours ouvert au centre de l'écran. Vous pouvez également déplacer l'affichage en appelant @{"MoveDisplay()" LINK MoveDisplay}. Width, Height : Vous devez seulement utiliser ces arguments si vous ne spécifiez pas une image de fond avec l'identification 1 et si vous voulez que les dimensions de votre écran soient différentes de la taille par défaut 640x480. Régler ces arguments aux dimensions désirées et Hollywood ouvrira un écran avec la résolution demandée. Color : Vous pouvez utiliser cet argument pour spécifier une couleur d'arrière plan pour votre écran. C'est seulement nécessaire si vous ne spécifiez pas une image de fond avec l'identification 1 et si vous voulez que la couleur de votre affichage soit différente du noir. Utiliser cet argument avec la couleur désirée et votre affichage aura cette couleur d'arrière plan. Desktop : Si vous réglez cet argument sur TRUE, l'image de fond sera une copie de votre écran de bureau. Ceci peut être utilisé pour certains effets sympathiques. Hollywood peut également ouvrir automatiquement une fenêtre sans bord si cet argument est validé à TRUE. Les arguments suivants changent l'apparence de votre script. Vous pouvez également les spécifier sur la @{"ligne de commande" LINK ManualUsage}. Si vous les spécifiez dans la commande préprocesseur @DISPLAY, ils seront fixes et ne pourront être modifiés de la ligne de commande. Par exemple, si vous voulez que votre script fonctionne toujours en mode plein écran, vous devez spécifier cela en utilisant la commande préprocesseur @DISPLAY. Alors le script sera toujours exécuté en mode plein écran - même si l'utilisateur l'exécute avec @{"les arguments de fenêtre" LINK ManualUsage}. Ainsi, tous les arguments suivants sont prioritaires sur les arguments de la ligne de commande. Mode : Définit le mode d'écran d'exécution de votre script. Cela peut être: Windowed, FullScreen, OwnScreen, FakeFullScreen, ou "Ask". Voir @{"les arguments de la console" LINK ManualUsage} pour découvrir ce que signifie ces différents modes. Si vous spécifiez "Ask", Hollywood demandera à l'utilisateur si le script s'exécutera dans le mode plein écran ou le mode fenêtre. Borderless : Régler cet argument sur TRUE si Hollywood doit ouvrir une fenêtre sans bord. Sizeable : Régler cet argument sur TRUE si Hollywood doit ouvrir une fenêtre redimensionnable. Si " Borderless " est paramétré sur TRUE, le gadget de redimensionnement sera invisible mais présent. Fixed : Si vous réglez cet argument sur TRUE, Hollywood ouvrira une fenêtre fixe. C'est particulièrement utile sur le mode plein écran. HideTitleBar : Cet argument peut être utilisé pour cacher la bar de titre de l'écran. Il prend seulement effet quand Hollywood s'ouvre sur son propre écran ou quand vous utilisez un remplissage de fond (backfill). Backfill : Définit si Hollywood installera un fond d'écran pour votre script. Prend un tableau en tant qu'argument. Ce tableau contient les arguments suivants: Type : Cet argument est obligatoire. Cela peut être: "Color", "Gradient", "Texture" ou "Picture". Color : Si vous spécifiez "color" comme type de remplissage de fond, indiquer la couleur de fond désiré dans cet argument. StartColor, EndColor : Si vous spécifiez " Gradient " comme type de remplissage de fond, utiliser ces deux arguments pour définir les couleurs de début et de fin pour le dégradé de couleur. Brush : Si vous spécifiez "Texture" ou "Picture" comme type de de remplissage de fond, spécifié l'identificateur de la brosse (brush) à utiliser comme image source. Si vous voulez utiliser directement le nom du fichier, utiliser l'étiquette "BrushFile". X, Y : Si vous spécifiez "Picture" comme type de remplissage de fond, vous pouvez utiliser ces deux arguments pour positionner l'image sur votre écran. Les deux par défaut sont réglé sur #CENTER. BrushFile : Si vous spécifiez "Texture" ou "Picture" comme type de remplissage de fond, vous pouvez spécifier le nom du fichier de la brosse (brush) pour l'utiliser comme image source. Le fichier spécifié ici sera lié à l'applet et/ou exécutable dans la compilation à moins que vous ayez réglé "LinkBrushFile" sur FALSE. Si vous voulez utiliser un identificateur de brosse (brush), utiliser l'étiquette "Brush". (V4.0) LinkBrushFile : Si "BrushFile" est spécifié cette étiquette pourra être utilisé pour déclarer si oui ou non le fichier brosse (Brush) sera incorporé dans l'applet et/ou l'exécutable par la compilation. Par défaut : TRUE, se qui signifie que le fichier brosse (Brush) sera incorporé. (V4.0) Transparency : Si le type de remplissage est "Picture", vous pourrez spécifier une couleur au format RGB qui sera visible d'une manière transparente. Par défauts sur: #NOTRANSPARENCY. (V4.0) ScalePicture : Si le type de remplissage est "Picture" vous pourrez utiliser cette étiquette pour définir si oui ou non l'image doit être redimensionner pour être adapter aux dimensions de la fenêtre. Par défauts sur FALSE. (V4.0) ScrHeight, ScrWidth : Ces deux arguments peuvent être utilisé en connection avec (V3.0) Mode="OwnScreen". Vous pouvez les utiliser pour spécifier les dimensions d'écran qu'Hollywood ouvrira. Si vous indiquez zéro Hollywood utilisera les dimensions de l'écran de bureau. Si vous ne les spécifié pas Hollywood déterminera automatiquement la taille d'écran. ScrDepth : Cet argument peut être utilisé pour spécifier le nombre de (V3.0) couleurs de l'affichage qu'Hollywood doit ouvrir. Ainsi, il peut seulement être utilisé quand Hollywood s'ouvre en mode pleine écran. Si vous ne spécifié pas cet argument, Hollywood utilisera le nombre de couleurs de l'écran de bureau pour le nouvel écran. HidePointer : Si vous spécifiez cet argument, le pointeur de la souris sera (V3.0) automatiquement caché dès qu'Hollywood ouvrira un mode plein écran ou un faux mode de plein écran. Cet argument a un avantage par rapport à la commande @{"HidePointer()" LINK HidePointer} parce qu'il cache le pointeur de la souris dans le mode pleine écran. Si Hollywood s'ouvre en mode fenêtre, le pointeur de la souris restera visible parce que cacher le pointeur de la souris dans le mode fenêtre entraîne habituellement une confusion chez l'utilisateur. NoModeSwitch : Si vous spécifiez cet argument il ne sera pas possible de (V3.0) commuter entre le mode fenêtre et pleine écran en actionnant la combinaison de touche COMMAND+RETURN. Si NoModeSwitch est spécifié, Hollywood restera toujours dans son mode d'écran initial et aucun basculement entre le mode fenêtre et le mode plein écran ne sera possible. @{b}INPUTS@{ub} table - un tableau contenant un ou plusieurs des indicateurs indiqués ci-dessus @{b}EXEMPLES@{ub} @DISPLAY {Title = "My App", X = #LEFT, Y = #TOP, Width = 320, Height = 240, Color = #WHITE} La déclaration ci-dessus ouvre un écran de 320x240 avec un fond blanc. L'écran est positionné au bord de l'écran (en haut à gauche). Le titre de la fenêtre sera "My App". --- @DISPLAY {Backfill = {Type = "Gradient", StartColor = #BLACK, EndColor = #BLUE}} Cette déclaration affichera un dégradé du noir au bleu comme fond d'écran. @ENDNODE @NODE atINCLUDE "Guide Hollywood" @{b}NOM@{ub} INCLUDE -- importer Le code des fichiers script ou des applet externes (V2.0) @{b}SYNOPSIS@{ub} @INCLUDE file$ @{b}FONCTION@{ub} Cette commande préprocesseur importera tout le code à partir du fichier spécifié par @{b}file$@{ub} dans le projet en cours. Le code sera inséré dans le projet en cours à l a position où @INCLUDE est défini. Normalement, vous devrez utiliser @INCLUDE au début de votre projet. Cette commande préprocesseur est utile si vous avez un grands projet et que voulez le découper en fichiers multiples. Les fichiers inclus contiennent habituellement des fonctions que vous pouvez appeler dans votre script principale. Les fichiers inclus peuvent également contenir des commandes préprocesseur. Depuis Hollywood 4.0, vous pouvez également inclure des applet Hollywood en utilisant cette commande. C'est utile pour importer Le code des bibliothèques. Veuillez consulter le @{"chapitre sur les fichiers d'inclusion" LINK V6PrgIncludes} pour plus d'informations. @{b}INPUTS@{ub} file$ - fichier script à inclure @{b}EXEMPLE@{ub} ;---File: script2.hws--- Function p_Print(t$) Print(t$) EndFunction ;EOF script2.hws ;---File: mainscript.hws @INCLUDE "script2.hws" p_Print("Hello World!") WaitLeftMouse End ;EOF mainscript.hws Le code ci-dessus se compose en deux script: script 2.hws contient la fonction p_Print() qui appelle simplement la fonction Hollywood @{"Print()" LINK Print}. script 2.hws est alors inséré dans le script principale qui appelle également la fonction p_Print(). @ENDNODE @NODE atVERSION "Guide Hollywood" @{b}NOM@{ub} VERSION -- définir la version d'Hollywood exigé (V2.0) @{b}SYNOPSIS@{ub} @VERSION version, revision @{b}FONCTION@{ub} Cette commande préprocesseur vous permet de définir la version compatible Hollywood sur lequel votre script doit fonctionner. Vous devrez toujours utiliser cette commande préprocesseur comme première élément dans votre script. @{b}INPUTS@{ub} version - version de Hollywood révision - mise à jour de Hollywood @{b}EXEMPLE@{ub} @VERSION 2.0 Définit que ce script exige au moins Hollywood 2.0. @ENDNODE @NODE atBGPIC "Guide Hollywood" @{b}NOM@{ub} BGPIC -- précharger une image de fond pour un usage ultérieur (V2.0) @{b}SYNOPSIS@{ub} @BGPIC id, filename$[, table] @{b}FONCTION@{ub} Cette commande préprocesseur précharge l'image de fond spécifié par @{b}filename$@{ub} et l'identifie avec @{b}id@{ub}. Le troisième argument est un tableau qui peut être utilisé pour spécifier une couleur qui sera transparente. Vous devez régler l'argument "Transparency" à la couleur que vous voulez avoir d'une manière transparente. En outre, le tableau a un argument "Link" qui vous permet de spécifier si ou non l'image sera lié au script quand il sera compilé. Cet argument est réglé par défaut sur True, se qui signifie que l'image sera jointe. Les formats d'image supportés sont PNG, JPEG, BMP, IFF ILBM, et bien plus selon la plate-forme sur laquelle Hollywood fonctionne. La couleur transparente doit être spécifiée dans une @{"notation RGB" LINK RGBInfo}. Si vous spécifiez 1 comme identificateur, alors cette image sera utilisé comme image de fond quand Hollywood ouvrira votre écran. Si vous voulez charger des images de fond manuellement, utiliser la commande @{"LoadBGPic()" LINK LoadBGPic}. @{b}INPUTS@{ub} id - une valeur qui est utilisée pour identifier cette image de fond plus tard dans le code; si c'est 1, alors l'image sera le fond d'écran par défaut filename$ - le fichier image que vous voulez charger table - optionnel: un tableau contenant les indicateurs "Transparency" et/ou "Link"; voir ci-dessus pour les explications. @{b}EXEMPLE@{ub} @BGPIC 1, "dh0:MyBG.iff" Déclare " dh0 :MyBG.iff " comme image de fond par défaut (sera affiché quand Hollywood s'exécutera). --- @BGPIC 1, "dh0:MyBG.iff", {Transparency = $FF0000} Fait la même chose que ci-dessus mais l'image est maintenant transparente (la couleur de transparence est le rouge=$FF0000). --- @BGPIC 1, "4MB_uncompressed_picture.bmp", {Link = False} Le code au-dessus charge l'image spécifié et indique à Hollywood qu'il ne devra jamais joindre cette image. @ENDNODE @NODE atANIM "Guide Hollywood" @{b}NOM@{ub} ANIM -- précharger une animation pour un usage ultérieur (V2.0) @{b}SYNOPSIS@{ub} identification de @ANIM, filename$ [, tableau] @{b}FONCTION@{ub} Cette commande préprocesseur précharge l'animation spécifié dans @{b}filename$@{ub} et l'identifie, les animations doivent être dans le format IFF ANIM. Plus de formats seront supportés dans le future. Le troisième argument est optionnel. C'est un tableau qui peut être utilisé pour régler d'autres options pour le chargement d'opérations. Les arguments suivants du tableau peuvent être utilisé: Transparency: Cet argument peut être utilisé pour spécifier une couleur dans la @{"notation RGB" LINK RGBInfo}, cela crééra un transparent dans l'animation. FromDisk : Si vous réglez cet argument sur TRUE, Hollywood ne chargera pas (V3.0) l'animation entière dans la mémoire mais elle chargera les images directement à partir du disque lorsqu'il en à besoin. C'est plus lent mais exige beaucoup moins de mémoire. Pour les commandes de la bibliothèque d'animation il n'est pas important que l'animation soit completement chargé dans la mémoire ou chargé dynamiquement à partir du disque. Vous pouvez utiliser toutes les commandes d'animation comme @{"ScaleAnim()" LINK ScaleAnim} également avec les animations qui sont chargés à partir du disque. Les calques d'Animations sont également correctement traitées avec des animations sur disque. Link : Régler cet argument sur False si vous ne voulez pas avoir cette animation lié à votre exécutable/applet quand vous compilez votre script. Cet argument est réglé par défaut sur True se qui signifie que l'animation est jointe à votre script. @{b}INPUTS@{ub} id - une valeur qui est utilisée pour identifier cette animation plus tard dans le code filename$ - le fichier d'animation que vous voulez charger table - optionnel: un tableau qui peut contenir les arguments suvant: "Transparency", "FromDisk" et "Link"; voir ci-dessus pour les explications. @{b}EXEMPLE@{ub} @ANIM 1, "dh0:MyAnim.iff" Load "dh0:MyAnim.iff" as animation number 1. --- @ANIM 1, "dh0:MyAnim.iff", {Transparency = $FF0000} Fait la même chose que ci-dessus mais l'animation est maintenant transparente (la couleur de transparence est rouge=$FF0000). --- @ANIM 1, "Huge_Animation.iff", {Link = False} Le code au-dessus charges l'animation spécifié et indique à Hollywood qu'il ne dois pas lié cet animation parce qu'elle est trop grande. @ENDNODE @NODE atSAMPLE "Guide Hollywood" @{b}NOM@{ub} SAMPLE -- précharger un échantillon sonore pour un usage ultérieur (V2.0) @{b}SYNOPSIS@{ub} @SAMPLE id, filename$[, table] @{b}FONCTION@{ub} Utiliser cette commande préprocesseur pour précharger un échantillon sonore que vous voulez jouer plus tard en utilisant @{"PlaySample()" LINK PlaySample}. Le troisième argument est un tableau qui peut être utilisé pour spécifier si oui ou non cet échantillon sonore sera lié au script quand il sera compilé. Cet argument est réglé par défaut sur True, se qui signifie que l'échantillon sera joint. Les formats sonores supportés sont WAVE, IFF 8SVX, IFF 16SV, ainsi que d'autres formats selon la plate-forme sur laquelle Hollywood est exécuté. Si vous voulez charger l'échantillon manuellement, utiliser la commande @{"LoadSample()" LINK LoadSample}. @{b}INPUTS@{ub} id - une valeur qui est utilisée pour identifier cet échantillon plus tard dans le code filename$ - échantillon sonore que vous voulez chargé table - optionnel: un tableau contenant l'argumet "Link"; voir ci-dessus pour les explications. @{b}EXEMPLE@{ub} @SAMPLE 1, "dh0:Sound/Samples/Gunshot.8svx" La déclaration ci-dessus affecte l'échantillon numéro 5 à l'échantillon: "dh0:Sound/Samples/Gunshot.8svx". ---- @SAMPLE 1, "dh0:Sound/Samples/Gunshot.8svx", {Link=False} Fait la même chose qu'au-dessus mais l'échantillon ne sera pas joint quand le script sera compilé. @ENDNODE @NODE atFILE "Guide Hollywood" @{b}NOM@{ub} FILE -- ouvrir un fichier pour un usage ultérieur (V2.0) @{b}SYNOPSIS@{ub} @FILE id, filename$[, table] @{b}FONCTION@{ub} Cette commande préprocesseur peut être utilisée pour ouvrir un fichier que vous pouvez utiliser plus tard. Le fichier ne sera pas chargé complètement dans la mémoire, il est juste ouvert comme si vous avez appelé @{"OpenFile()" LINK OpenFile}. Le fichier sera toujours ouvert en mode de lecture seule. Vous ne pouvez pas utiliser cette commande préprocesseur pour écrire dans le fichier. La caractéristique novatrice de la commande préprocesseur @FILE est que quand vous compilez votre script, le fichier sera lié au script principale et vous pourrez encore y accéder de la même manière que si c'était un fichier normal disponible sur votre disque dur, par exemple vous pouvez utiliser les commandes de la @{"bibliothèque DOS" LINK V6LibDOSFunctions} sur le fichier. Le troisième argument est un tableau qui peut être utilisé pour spécifier si oui ou non ce fichier sera lié au script quand il sera compilé. Cet argument est réglé par défaut sur True, se qui signifie que le fichier sera joint. Si vous voulez ouvrir le fichier manuellement, utiliser la commande @{"OpenFile()" LINK OpenFile} @{b}INPUTS@{ub} id - une valeur qui est utilisée pour identifier ce fichier plus tard dans le code filename$ - le fichier que vous voulez ouvrir table - optionnel: un tableau contenant l'argument "Link"; voir ci-dessus pour les explications. @{b}EXEMPLE@{ub} @FILE 1, "S:Startup-Sequence" La déclaration ci-dessus ouvre le fichier "S:Startup-Sequence" pour un traitement dans le script. @ENDNODE @NODE atBRUSH "Guide Hollywood" @{b}NOM@{ub} BRUSH -- précharger une brosse (brush) pour un usage ultérieur (V2.0) @{b}SYNOPSIS@{ub} @BRUSH id, filename$[, table] @{b}FONCTION@{ub} Cette commande préprocesseur précharge la brosse spécifié dans @{b}filename$@{ub} et le sauvegarde sous l'identification @{b}id@{ub}. Les formats supportés d'image sont PNG, JPEG, BMP, IFF ILBM, ainsi que d'autres formats selon la plate-forme sur laquelle Hollywood sera exécuté. Le troisième argument est optionnel. C'est un tableau qui peut être utilisé pour régler d'autres options pour les opérations de chargement. Les arguments suivants du tableau peuvent être utilisé: Transparency : Cet argument peut être utilisé pour spécifier une couleur dans la @{"notation RGB" LINK RGBInfo} qui crééra un transparent dans la brosse (brush). LoadAlpha : Régler cet argument pour valider si le canal alpha de l'image doit être chargé. Veuillez noter que toutes les images n'ont pas un canal alpha et également que tous les formats d'images ne sont pas forcément capables de stocker l'information de canal alpha. vous devez utiliser le format PNG si vous voulez les données de canal alpha. Cet argument est réglé par défaut sur False. Link : Régler cet argument à False si vous ne voulez pas avoir cette brosse (brush) lié à votre exécutable ou applet quand vous compilez votre script. Cet argument est réglé par défaut sur True, se qui signifie que la brosse (brush) est joint à votre script. X, Y, Width, Height : Ces arguments peuvent être utilisés pour charger une partie seulement de l'image dans la brosse(brush). C'est utile si vous avez une grande image qui regroupe plusieurs différentes petites images et que vous voulez charger que les petites images dans une seule brosse (brush). Ces arguments que vous permettent de définir un rectangle à l'intérieur de l'image dans lequel Hollywood prendra les données graphique pour la brosse (brush). Veuillez noter que les arguments "transparency" et " LoadAlpha " sont mutuellement exclusifs. Une brosse (brush) peut avoir seulement qu'un réglage de transparence. Si vous voulez charger des brosses (brush) manuellement, utiliser la commande @{"LoadBrush()" LINK LoadBrush}. @{b}INPUTS@{ub} id - une valeur qui est utilisée pour identifier cette brosse (brush) plus tard dans le code filename$ - le fichier image que vous voulez charger table - argument optionnel spécifiant d'autres options @{b}EXEMPLE@{ub} @BRUSH 1, "dh0:MyBrush.iff" Charge " dh0 :MyBrush.iff " en tant que brush 1 sans la transparence. ---- @BRUSH 1, "dh0:MyBrush.iff", {Transparency = $FF0000} Fait la même chose que ci-dessus mais la brosse (brush) est maintenant transparent (la couleur de transparence est rouge=$FF0000). ---- @BRUSH 1, "dh0:Sprites.iff", {X = 64, Y = 32, Width = 32, Height = 32} Charge une image de 32x32 Pixel de "dh0:Sprites.iff" commençant à X=64 et Y=32. @ENDNODE @NODE atSPRITE "Guide Hollywood" @{b}NOM@{ub} SPRITE -- précharger un sprite pour un usage ultérieur (V2.0) @{b}SYNOPSIS@{ub} @SPRITE id, filename$[, table] @{b}FONCTION@{ub} Cette commande préprocesseur précharge le sprite spécifié dans @{b}filename$@{ub} et le sauvegarde sous l'identification @{b}id@{ub} Les formats supportés d'image sont PNG, JPEG, BMP, IFF ILBM, ainsi que d'autres formats selon la plate-forme sur lequel Hollywood est exécuté. Le troisième argument est optionnel. C'est un tableau qui peut être utilisé pour régler d'autres options pour les opérations de chargement. Les arguments suivants du le tableau peuvent être utilisé : Transparency: Cet argument peut être utilisé pour spécifier une couleur dans la @{"notation RGB" LINK RGBInfo} qui crééra un transparent dans le sprite. LoadAlpha : Régler cet argument pour valider si le canal alpha de l'image sera chargé. Noter que toutes les images n'ont pas forcément de canal alpha et également que tous les formats d'images ne sont pas forcément capables de stocker l'information de canal alpha. Vous devez utilisez le format PNG si vous avez besoin des données du canal alpha. Cet argument est réglé par défaut sur False. Link : Régler cet argument à False si vous ne voulez pas avoir ce sprite lié à votre exécutable/applet quand vous compilez votre script. Cet argument est réglé par défaut sur True se qui signifie que le sprite est joint à votre script. X, Y, Width Height Frames FPR : Cet ensemble d'arguments peut être utilisé pour affiner les opérations de chargement. Vous pouvez utiliser ces arguments pour utiliser @SPRITE qui créé un sprite avec des images multiple dans une seule image. les dimensions du sprite et "Frames" spécifie combien d'images comporte le @SPRITE qui seront lues depuis l'image source et leurs tailles. Si les images sont alignés dans plusieurs rangées dans l'image source et vous devrez également utiliser l'argument "FPR" (nombre d'images par colonnes) pour dire à @SPRITE combien d'images il y a dans chacune des rangée. En conclusion, vous pouvez dire à @SPRITE où dans l'image elle devrait commencer le scan en spécifiant les arguments "X" et "Y" (les deux sont réglé par défaut sur 0). @SPRITE commencera alors à la position "X":"Y" et lira "Frames" qui est le nombre d'images avec les dimensions de "Width" par "Height" de l'image spécifié par filename$. Après qu'il ait lu le nombre "FPR" des images, il avancera à la prochaine rangée. Noter que les arguments "Transparency" et "LoadAlpha" sont mutuellement exclusif. Un sprite peut seulement avoir un réglage de transparence. Si vous voulez charger des sprites manuellement, utiliser la commande @{"LoadSprite()" LINK LoadSprite}. @{b}INPUTS@{ub} id - une valeur qui est utilisée pour identifier ce sprite plus tard dans le code filename$ - le fichier image que vous voulez charger table - argument optionnel spécifiant d'autres options @{b}EXEMPLE@{ub} @SPRITE 1, "dh0:MySprite.iff", {Transparency = #RED} Ceci charge " dh0 :MySprite.iff " comme sprite 1 avec le rouge en couleur transparente. ---- @SPRITE 1, "dh0:PlayerSprites.iff", {Width = 32, Height = 32, Frames = 16, FPR = 8, Transparency = #BLACK} Le code ci-dessus créé un sprite 1 à partir du fichier "dh0:PlayerSprites.iff" Le sprite 1 aura des dimensions de 32x32 pixel et contiendra 16 différentes image. Les images sont alignés avec 8 images par rangée dans l'image "dh0:PlayerSprites.iff" Ainsi, @SPRITE doit scanner deux rangées pour charger les 16 images. @ENDNODE @NODE atMUSIC "Guide Hollywood" @{b}NOM@{ub} MUSIC -- précharger une musique pour un usage ultérieur (V2.0) @{b}SYNOPSIS@{ub} @MUSIC id, filename$[, table] @{b}FONCTION@{ub} Utiliser cette commande préprocesseur afin de précharger une musique que vous voulez jouer plus tard en utilisant @{"PlayMusic()" LINK PlayMusic}. La musique peut être dans n'importe quel format compatible avec Hollywood. Veuillez lire la documentation de @{"OpenMusic()" LINK OpenMusic} pour obtenir des informations sur les formats de musique compatible. Si la musique est dans un format de streaming audio (par exemple du MPEG audio), cette commande préprocesseur initialisera seulement la musique pour une lecture ultérieur. Il ne chargera pas de grandes musiques complètement dans la mémoire mais elles seront jouées comme du streaming audio mis en mémoire tampon à partir du disque. Le troisième argument est un tableau qui peut être utilisé pour spécifier si oui ou non cette musique sera liée au script quand elle sera compilée. Cet argument a comme valeur par défaut True, qui signifie que la musique sera jointe. Depuis Hollywood 2.5, Hollywood joindra également des fichiers audio MPEG dans votre applet/exécutable et le lira directement de là ou il se trouve en streaming. Vous pouvez désactiver cette option en réglant "Link" à False. Si vous voulez ouvrir la musique manuellement, utiliser la commande @{"OpenMusic()" LINK OpenMusic}. @{b}INPUTS@{ub} id - une valeur qui est utilisée pour identifier cette musique plus tard dans le code filename$ - le fichier que vous voulez chargé table - optionnel: un tableau contenant l'argument "Link"; voir ci-dessus pour l'explication @{b}EXEMPLE@{ub} @MUSIC 1, "dh0:TurricanII_Remix.mp3" Le code ci-dessus ouvre "dh0:TurricanII_Remix.mp3" de sorte qu'il puisse être joué plus tard en utilisant @{"PlayMusic()" LINK PlayMusic}. @ENDNODE @NODE atAPPAUTHOR "Guide Hollywood" @{b}NOM@{ub} APPAUTHOR -- déclarer l'auteur de l'application (V2.0) @{b}SYNOPSIS@{ub} @APPAUTHOR author$ @{b}FONCTION@{ub} Cette commande préprocesseur vous permet simplement d'allouer une chaîne qui contiendra l'identité de l'auteur du script dans l'application. Cette commande n'a pas de fonction réel. Il prend juste la chaîne spécifié et la sauvegarde dans l'applet/exécutable. @{b}INPUTS@{ub} authors - auteur du script @{b}EXEMPLE@{ub} voir @{"@APPVERSION" LINK atAPPVERSION} @ENDNODE @NODE atAPPCOPYRIGHT "Guide Hollywood" @{b}NOM@{ub} APPCOPYRIGHT -- déclarer les droits de publication de l'application (V2.0) @{b}SYNOPSIS@{ub} @APPCOPYRIGHT copyright$ @{b}FONCTION@{ub} Cette commande préprocesseur vous permet simplement d'allouer une chaîne qui contiendra les droits de publication du script dans l'application. Cette commande n'a aucune fonction réel. Elle prend juste la chaîne spécifié et la sauvegarde dans l'applet/exécutable. @{b}INPUTS@{ub} copyright$ - Droit d'auteur du script @{b}EXEMPLE@{ub} voir @{"@APPVERSION" LINK atAPPVERSION} @ENDNODE @NODE atAPPDESCRIPTION "Guide Hollywood" @{b}NOM@{ub} APPDESCRIPTION -- déclarer la description d'application (V2.0) @{b}SYNOPSIS@{ub} @APPDESCRIPTION desc$ @{b}FONCTION@{ub} Cette commande préprocesseur vous permet simplement d'allouer une chaîne qui contiendrà la description du script dans l'application. Cette commande n'a aucune fonction réel. Elle prend juste la chaîne spécifié et la sauvegarde dans l'applet/exécutable. Sous AmigaOS, la description spécifié ici est utilisée comme description de la commodité qui est ajoutée dans l'échange. @{b}INPUTS@{ub} desc$ - description du script @{b}EXEMPLE@{ub} voir @{"@APPVERSION" LINK atAPPVERSION} @ENDNODE @NODE atAPPTITLE "Guide Hollywood" @{b}NOM@{ub} APPTITLE -- déclarer le titre d'application (V2.0) @{b}SYNOPSIS@{ub} @APPTITLE title$ @{b}FONCTION@{ub} Cette commande préprocesseur vous permet simplement d'allouer une chaîne qui contiendra le titre du script dans l'application. Cette commande n'a aucune fonction réelle. Elle prend juste la chaîne spécifié et la sauvegarde dans l'applet/exécutable. Sous AmigaOS, le titre spécifié ici est utilisé comme titre de commodité qui est ajoutée dans l'échange. @{b}INPUTS@{ub} title$ - titre du script @{b}EXEMPLE@{ub} voir @{"@APPVERSION" LINK atAPPVERSION} @ENDNODE @NODE atAPPVERSION "Guide Hollywood" @{b}NOM@{ub} APPVERSION -- déclarer la version d'application (V2.0) @{b}SYNOPSIS@{ub} @APPVERSION version$ @{b}FONCTION@{ub} Cette commande préprocesseur vous permet simplement d'allouer une chaîne qui contiendrà la version du script dans l'application. Cette commande n'a aucune fonction réelle. Elle prend juste la chaîne spécifié et la sauvegarde dans l'applet/exécutable. Sous AmigaOS, le titre spécifié ici est utilisé comme titre de commodité qui est ajoutée dans l'échange. @{b}INPUTS@{ub} version$ - version du script @{b}EXEMPLE@{ub} @APPTITLE "Run-away Randy" @APPCOPYRIGHT "(C) Copyright 2002-2005 by Airsoft Softwair." @APPVERSION "$VER: Run-away Randy 1.0 (23-Dec-05)" @APPDESCRIPTION "A really cool jump'n'run game done with Hollywood." C'est à cette partie que ressemble les informations sur l'application. Hollywood sauvegardera toute cette information dans l'applet et/ou exécutable et quand l'utilisateur utilisera : "Version dh0:Run-away-Randy.exe", la chaîne version "$VER: Run-away Randy 1.0 (23-Dec-05)" sera retourné. @ENDNODE @NODE V6PrgPreproc "Guide Hollywood" @{b}commandes préprocesseur@{ub} Une commande préprocesseur est une commande qu'Hollywood exécute avant que votre script soit lancé. Elles sont principalement utilisés pour précharger des données avant que le script démarre. Par exemple, si votre script exige les fichiers "mainmenu.iff", "gamescreen.iff" et "music.mod", dans tous les cas, vous pourriez simplement les précharger en utilisant Le code suivant : @BGPIC 1, "mainmenu.iff" @BGPIC 2, "gamescreen.iff" @MUSIC 1, "music.mod" Hollywood chargera alors tous ces fichiers avant d'exécuter votre script. Tous les fichiers qui sont chargé par l'intermédiaire des commandes préprocesseur sont immédiatement prêts pour une utilisation quand votre script démarre. La plupart des commandes LoadXXX() ont leurs équivalent comme commande préprocesseur avec Hollywood. Par exemple: - la commande préprocesseur équivalente de @{"LoadBrush()" LINK LoadBrush} est @{"@BRUSH" LINK atBRUSH} - la commande préprocesseur équivalente de @{"LoadBGPic()" LINK LoadBGPic} est @{"@BGPIC" LINK atBGPIC} et ainsi de suite... Les commandes préprocesseur sont toujours préfixées par le caractère (@). Vous devrez également les écrire en majuscules de sorte qu'elles puissent être mieux distinguées des commandes classiques. Les commandes préprocesseur peuvent être mises n'importe où dans le script, mais pour des raisons de lisibilité il serait plus judicieux de les mettre au début de vos scripts. Une commande préprocesseur élémentaire est la commande @{"@VERSION" LINK atVERSION}. Vous devez l'utiliser comme première ligne de code dans chacun de vos script. @{"@VERSION" LINK atVERSION} vérifie si la version Hollywood utilisée est compatible pour faire fonctionner votre script. Si se n'est pas le cas, Hollywood s'arrêtera. La plupart des commandes préprocesseur prennent plusieurs arguments qui sont séparés par des virgules comme les commandes classiques. Vous pouvez également utiliser des expressions dans les commandes préprocesseur. Par exemple, la déclaration suivante serait parfaitement compatible: @BRUSH 5+5, "dh0:MyBrush.iff" Ceci chargerait "dh0:MyBrush.iff" comme brosse(brush) numéro 10. Cependant, Ce que vous ne pouvez pas faire, c'est d'utiliser des variables dans vos expressions. Quand Hollywood analyse les commandes préprocesseur, il ne sait rien au sujet des valeurs de variables parce que le script n'a pas encore démarré. Ainsi, toutes les expressions que vous utilisez doivent contenir des constantes. Toutes les commandes préprocesseurs qui charge des fichiers reçoivent l'argument "Link". Cet argument indique au lieur d'Hollywood si oui ou non le fichier de cette commande préprocesseur sera incorporée dans l'exécutable ou l'applet quand vous compilerez le script. L'argument "Link" est toujours réglé par défaut sur True, se qui signifie que par défaut, tous les fichiers chargés par des commandes préprocesseur seront lié à votre exécutable ou applet. Si vous ne voulez pas que certains fichiers soient liés, par exemple parce qu'ils sont trop volumineux, vous devrez le spécifier explicitement dans la commandes préprocesseur correspondante. Les commandes préprocesseur suivantes sont disponible: @{"@ANIM " LINK atANIM } précharger une animation pour un usage ultérieur (V2.0) @{"@APPAUTHOR " LINK atAPPAUTHOR } déclarer l'auteur de l'application (V2.0) @{"@APPCOPYRIGHT " LINK atAPPCOPYRIGHT } déclarer les droits de publication de l'application (V2.0) @{"@APPDESCRIPTION " LINK atAPPDESCRIPTION} déclarer la description d'application (V2.0) @{"@APPTITLE " LINK atAPPTITLE } déclarer le titre d'application (V2.0) @{"@APPVERSION " LINK atAPPVERSION } déclarer la version d'application (V2.0) @{"@BGPIC " LINK atBGPIC } précharger une image de fond pour un usage ultérieur (V2.0) @{"@BRUSH " LINK atBRUSH } précharger une brosse (brush) pour un usage ultérieur (V2.0) @{"@FILE " LINK atFILE } ouvrir un fichier pour un usage ultérieur (V2.0) @{"@DISPLAY " LINK atDISPLAY } définir les attributs d'écran (V2.0) @{"@INCLUDE " LINK atINCLUDE } importer Le code des fichiers script ou des applet externes (V2.0) @{"@MUSIC " LINK atMUSIC } précharger une musique pour un usage ultérieur (V2.0) @{"@SAMPLE " LINK atSAMPLE } précharger un échantillon sonore pour un usage ultérieur (V2.0) @{"@SPRITE " LINK atSPRITE } précharger un sprite pour un usage ultérieur (V2.0) @{"@VERSION " LINK atVERSION } définir la version d'Hollywood exigé (V2.0) Pour des raisons de compatibilité, Hollywood 2.0 émule également les commandes préprocesseur d'Hollywood 1.x (elles sont appelées "mots clés"). Voici une liste des commandes préprocesseur d'Hollywood 1.x qui sont émulées. Veuillez ne plus les utiliser. Chacune de ces commandes a un équivalent pour Hollywood 2.0 et supérieur. @{"%ANIM " LINK ANIM } précharger une animation pour un usage ultérieur @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"%BGPIC " LINK BGPIC } précharger une image de fond pour un usage ultérieur @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"%BRUSH " LINK BRUSH } précharger une brosse pour un usage ultérieur @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"%BUTTON " LINK BUTTON } déclarer un bouton @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"%CODE " LINK CODE } déclarer la fin de la section de mots clés @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"%CONSTANT " LINK CONSTANT } déclarer une constante (V1.5) @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"%DISPLAYCOLOR " LINK DISPLAYCOLOR } définir la couleur pour le fond d'écran initial (V1.5) @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"%DISPLAYDESKTOP " LINK DISPLAYDESKTOP} utiliser l'écran de bureau comme image de fond (V1.5) @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"%DISPLAYSIZE " LINK DISPLAYSIZE } définir les dimensions pour la taille initiale de l'écran @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"%HOLLYWOOD " LINK HOLLYWOOD } définir quelle version d'Hollywood est exigé pour votre script @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"%KEYDOWN " LINK KEYDOWN } déclarer une touche @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"%MODULE " LINK MODULE } précharger un module de musique pour un usage ultérieur @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"%SAMPLE " LINK SAMPLE } précharger un échantillon sonore pour un usage ultérieur @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"%TITLE " LINK TITLE } déclarer le titre de votre application @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @ENDNODE @NODE CreateButton "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} CreateButton -- Créer un nouveau bouton @{b}SYNOPSIS@{ub} CreateButton(id,x1,y1,x2,y2) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Veuillez utiliser @{"MakeButton()" LINK MakeButton}. Cette commande fait la même chose que le mot clé @{"%BUTTON" LINK BUTTON} mais c'est une commande et pas un mot clé. Le bouton spécifié par @{b}id@{ub} et les coordonnées @{b}x1:y1@{ub} et @{b}x2:y2@{ub} sont ajoutées à la base de données de bouton. Voir la documentation sur le mots clé @{"%BUTTON" LINK BUTTON} pour plus d'information. @{b}INPUTS@{ub} id - identificateur désiré pour le bouton x1 - bord gauche source y1 - bord haut source x2 - bord gauche de destination y2 - bord haut de destination @{b}EXEMPLE@{ub} voir le mot clé @{"%BUTTON" LINK BUTTON} @ENDNODE @NODE CreateKeyDown "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} CreateKeyDown -- créer un nouvel objet keydown (touche pressée) @{b}SYNOPSIS@{ub} CreateKeyDown(id,key$) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Utiliser les commandes de la nouvelle bibliothèque d'Hollywood 2.0 qui sont mieux exploités. Cette commande fait la même chose que le mots clé @{"%KEYDOWN" LINK KEYDOWN} mais c'est une commande et pas un mot clé. Voir la documentation du mots clé @{"%KEYDOWN" LINK KEYDOWN} pour les touches que vous pouvez spécifier dans @{b}key$@{ub}. @{b}INPUTS@{ub} id - identificateur désiré pour le bouton key$ - touche à tester @{b}EXEMPLE@{ub} voir le mot clé @{"%KEYDOWN" LINK KEYDOWN} @ENDNODE @NODE DisableEvent "Hollywwod Guide" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} DisableEvent -- désactiver un événement @{b}SYNOPSIS@{ub} DisableEvent(type,id) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Veuillez utiliser @{"DisableButton()" LINK DisableButton}. Cette commande désactive l'événement spécifié par @{b}type@{ub} et @{b}id@{ub}. Une fois qu'un événement est désactivé, il n'est plus contrôlable. Cependant, vous pouvez le réactiver de nouveau en utilisant @{"EnableEvent()" LINK EnableEvent}. Ne pas oublier de spécifier le préfixe "#" pour tous les événements parce que vous pouvez désactiver malencontreusement des constantes. @{b}INPUTS@{ub} type - type d'événement (par exemple #ONBUTTONOVER, #ONBUTTONCLICK, #CLOSEWINDOW) id - numéro d'événement à désactiver @{b}EXEMPLE@{ub} DisableEvent(#ONBUTTONOVER,1) DisableEvent(#ONBUTTONCLICK,1) DisableEvent(#ONBUTTONRIGHTCLICK,1) Le code ci-dessus désactive complètement le contrôle du bouton 1 (chaque bouton a ces 3 événements #ONBUTTONOVER, #ONBUTTONCLICK, #ONBUTTONRIGHTCLICK). Par conséquent si vous voulez désactiver un bouton, vous devrez utiliser DisableEvent() 3 fois. @ENDNODE @NODE EnableEvent "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} EnableEvent -- activer un événement @{b}SYNOPSIS@{ub} EnableEvent(type,id) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Veuillez utiliser @{"EnableButton()" LINK EnableButton}. Cette commande active l'événement spécifié par @{b}type@{ub} et @{b}id@{ub}. Une fois qu'un événement est activé, il sera contrôlé par Hollywood. Vous pourrez seulement appeler cette commande que si vous avez désactivé l'événement avant, parce que par défaut, tous les événements sont activés. Ne pas oublier de spécifier le préfixe "#" pour tous les événements parce que vous pouvez désactiver malencontreusement des constantes. @{b}INPUTS@{ub} type - type d'événement (par exemple #ONBUTTONOVER, #ONBUTTONCLICK, #CLOSEWINDOW) id - numéro d'événement à activer @{b}EXEMPLE@{ub} EnableEvent(#ONBUTTONOVER,1) EnableEvent(#ONBUTTONCLICK,1) EnableEvent(#ONBUTTONRIGHTCLICK,1) Le code ci-dessus active complètement le contrôle du bouton 1 (chaque bouton a ces 3 événements #ONBUTTONOVER, #ONBUTTONCLICK et #ONBUTTONRIGHTCLICK). Par conséquent si vous voulez désactiver un bouton vous devrez utiliser EnableEvent() 3 fois. @ENDNODE @NODE EnableEventHandler "Guide Hollywood" @{b}NOM@{ub} EnableEventHandler -- activer le gestionnaire d'événement d'Hollywood (V1.0 V1.5) @{b}SYNOPSIS@{ub} EnableEventHandler() @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande n'est plus compatible depuis Hollywood 1.9. Utiliser @{"CheckEvent()" LINK CheckEvent}. Cette commande active le gestionnaire d'événement interne d'Hollywood. Cela implique, que vous n'êtes plus obliger utiliser WaitEvent() puisque Hollywood vérifiera toujours s'il y a des événements qui se produisent. Utiliser le gestionnaire d'événement interne est utile si vous voulez exécuter des commandes quand il n'y a pas d'entrée, mais il contrôle également les actions de l'utilisateur, par exemple, si vous faites un diaporama avec quelques effets, vous ne pouvez pas exécuter WaitEvent() à chaque seconde mais si vous voulez que l'utilisateur puisse quitter à tous momment le diaporama en appuyant sur un bouton sur votre écran. il serait plus judicieux d'utiliser EnableEventHandler(), car une fois qu'il est activé, vous pouvez faire ce que vous voulez, et tous les événements seront encore contrôlés. Note: utiliser cette commande seulement quand vous en avez réellement besoin. Il existe d'importants désavantages comparés à une boucle créé avec WaitEvent() parce que vous ne saurez jamais quand un événement a été repéré et d'où. Si le gestionnaire d'événement Hollywood est activé, des événements seront toujours repérés. Il pourrait même se produire, qu'un événement d'interruption de commande soit toujours occupé, par exemple DisplayTransitionFX(). Ce n'est pas une bonne idée d'utiliser EnableEventHandler() dans vos projets parce que vous perdrez le contrôle de votre application. EnableEventHandler() est très susceptible d'être retiré des futures versions d'Hollywood. Utiliser la meilleur méthode, entre autre, une boucle d'entrée avec @{"WaitEvent()" LINK WaitEvent}. @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} EnableEventHandler DisplayBGPic(1) Wait(200) DisplayBGPic(2) Label(ONBUTTONCLICK1) End Le code ci-dessus active le gestionnaire d'événement et démarre un défilement d'image mais l'utilisateur sera toujours en mesure d'appuyer sur un bouton bien que vous n'appelez pas WaitEvent(). @ENDNODE @NODE DisableEventHandler "Guide Hollywood" @{b}NOM@{ub} DisableEventHandler -- désactiver le gestionnaire d'événement Hollywood (V1.0 - V1.5) @{b}SYNOPSIS@{ub} DisableEventHandler() @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande n'est plus compatible depuis Hollywood 1.9. Utiliser @{"CheckEvent()" LINK CheckEvent}. Cette commande désactive le gestionnaire d'événement interne d'Hollywood. Veuillez voir la documentation de @{"EnableEventHandler()" LINK EnableEventHandler} pour plus d'informations sur le gestionnaire d'événement interne. @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} voir @{"EnableEventHandler()" LINK EnableEventHandler} @ENDNODE @NODE ModifyButton "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} ModifyButton -- modifier les caractéristiques d'un bouton @{b}SYNOPSIS@{ub} ModifyButton(id,x1,y1,x2,y2) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Utiliser les commandes de la nouvelle bibliothèque d'Hollywood 2.0 qui sont mieux exploités. Cette commande modifie la configuration du bouton spécifiées par @{b}id@{ub} @{b}INPUTS@{ub} id - identificateur pour le bouton x1 - nouvelle position gauche désirée du bord y1 - nouvelle position désirée du bord x2 - nouvelle position gauche désirée du bord de destination y2 - nouvelle position désirée du bord de destination @ENDNODE @NODE ModifyKeyDown "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} ModifyKeyDown -- modifier les caractéristiques d'objet keydown @{b}SYNOPSIS@{ub} ModifyKeyDown (identification, key$) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Utiliser les commandes de la nouvelle bibliothèque d'Hollywood 2.0 qui sont mieux exploités. Cette commande modifie la configuration du keydown spécifiées par @{b}id@{ub}. Voir la documentation du mot clé @{"%KEYDOWN" LINK KEYDOWN} pour connaître les touches que vous pouvez spécifier dans @{b}key$@{ub}. @{b}INPUTS@{ub} id - identificateur pour le bouton key$ - nouvelle touche que vous voulez contrôler @ENDNODE @NODE ONBUTTONCLICK "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} ONBUTTONCLICK -- utiliser le clic d'un bouton @{b}SYNOPSIS@{ub} Label(ONBUTTONCLICKx) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Utiliser les commandes de la nouvelle bibliothèque d'Hollywood 2.0 qui sont mieux exploités. Cet événement est utilisé quand l'utilisateur effectue un clic sur un bouton déclaré. Hollywood utilisera la commande Gosub() pour effectuer un saut au label ONBUTTONCLICKx, x étant l'id du bouton. Par exemple, Hollywood effectue un saut par l'intermédiaire de la commande Gosub() au label nommé ONBUTTONCLICK15 quand l'utilisateur clic sur le bouton numéro 15. @{b}INPUTS@{ub} x - numéro de bouton @{b}EXEMPLE@{ub} voir le mot clé @{"%BUTTON" LINK BUTTON} @ENDNODE @NODE ONBUTTONOVER "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} ONBUTTONOVER -- Tester si le pointeur de la souris passe au-dessus d'un bouton @{b}SYNOPSIS@{ub} Label(ONBUTTONOVERx) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Utiliser les commandes de la nouvelle bibliothèque d'Hollywood 2.0 qui sont mieux exploités. Cet événement est utilisé quand l'utilisateur déplace la souris au-dessus d'un bouton. Hollywood utiliserà la commande Gosub() pour effectuer un saut au label ONBUTTONOVERx, x étant l'id du bouton. Par exemple, Hollywood utiliserà la commande Gosub() pour effectuer un saut au label ONBUTTONOVER15 quand l'utilisateur déplace la souris au-dessus du bouton numéro 15. @{b}INPUTS@{ub} X - numéro de bouton @{b}EXEMPLE@{ub} voir le mot clé @{"%BUTTON" LINK BUTTON} @ENDNODE @NODE ONKEYDOWN "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} ONKEYDOWN -- Tester si l'utilisateur a appuyé sur une touche @{b}SYNOPSIS@{ub} Label(ONKEYDOWNx) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Utiliser les commandes de la nouvelle bibliothèque d'Hollywood 2.0 qui sont mieux exploités. Cet événement est utilisé quand l'utilisateur appuie sur une touche testée. Hollywood utilisera la commande Gosub() pour effectuer un saut au label ONKEYDOWNx, x étant l'id du keydown. Par exemple, Hollywood utilisera la commande Gosub() pour effectuer un saut au label ONKEYDOWN15 quand l'utilisateur appuie sur la touche numéro 15. @{b}INPUTS@{ub} x - numéro principal @{b}EXEMPLE@{ub} voir le mot clé @{"%KEYDOWN" LINK KEYDOWN} @ENDNODE @NODE RemoveButton "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} RemoveButton -- retirer un bouton @{b}SYNOPSIS@{ub} RemoveButton(id) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Veuillez utiliser @{"DeleteButton()" LINK DeleteButton}. Cette commande retirera le bouton spécifié par id de la base de données de bouton d'Hollywood. Les événements du bouton ne seront plus utilisable. @{b}INPUTS@{ub} id - bouton à effacer @{b}EXEMPLE@{ub} RemoveButton(1) Efface le bouton 1 @ENDNODE @NODE RemoveKeyDown "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} RemoveKeyDown -- enlever un objet de keydown (touche pressée) @{b}SYNOPSIS@{ub} RemoveKeyDown(id) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Utiliser les commandes de la nouvelle bibliothèque d'Hollywood 2.0 qui sont mieux exploités. Cette commande enlèvera l'objet de keydown spécifié par id de la base de données keydown d'Hollywood. Les événements de ce keydown ne seront plus reçu. @{b}INPUTS@{ub} id - keydown à effacer @{b}EXEMPLE@{ub} RemoveKeydown(1) Efface l'objet keydown 1 @ENDNODE @NODE WhileMouseOn "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} WhileMouseOn -- arrêter jusqu'à ce que l'utilisateur déplace la souris hors d'un bouton @{b}SYNOPSIS@{ub} WhileMouseOn () @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Utiliser les commandes de la nouvelle bibliothèque d'Hollywood 2.0 qui sont mieux exploités. Cette commande peut être exécuté après qu'un événement ONBUTTONOVER se soit produit. Si vous exécutez cette commande, Hollywood attendra jusqu'à ce que l'utilisateur déplace la souris hors du bouton sur lequel il était dessus. C'est utile quand vous voulez afficher un brush quand la souris est au-dessus d'un bouton (effet de survole). Cette commande est optionnel après un événement ONBUTTONOVER (différent de la commande WhileMouseDown() qui est exigé après un événement ONBUTTONCLICK) @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} voir le mot clé @{"%BUTTON" LINK BUTTON} @ENDNODE @NODE WhileMouseDown "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} WhileMouseDown -- arrêter jusqu'à ce que le bouton de la souris soit relché @{b}SYNOPSIS@{ub} WhileMouseDown() @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Utiliser les commandes de la nouvelle bibliothèque d'Hollywood 2.0 qui sont mieux exploités. Cette commande doit être exécuté après qu'un événement ONBUTTONCLICK se soit produit. Si vous exécutez cette commande, Hollywood attendra jusqu'à ce que l'utilisateur ait relché son bouton de souris. Il est absolument nécessaire de lancer la commande après qu'un événement ONBUTTONCLICK se soit produit parce que même si l'utilisateur n'effectue qu'un seul clic avec la souris plusieurs événements peuvent être survenu. Afin d'utiliser le bon événement, exécuter juste la commande après qu'un événement ONBUTTONCLICK se soit produit. @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} voir le mot clé @{"%BUTTON" LINK BUTTON} @ENDNODE @NODE ACTIVEWINDOW "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} ACTIVEWINDOW -- activer une fenêtre @{b}SYNOPSIS@{ub} Label(ACTIVEWINDOW) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Veuillez utiliser @{"InstallEventHandler()" LINK InstallEventHandler} Hollywood utilisera la commande Gosub() pour effectuer un saut au label ACTIVEWINDOW afin d'activer de nouveau une fenêtre. Normalement vous n'avez pas besoin de cet événement, mais si vous voulez effectuer une tche quand votre fenêtre redevient active, utiliser cet événement. @{b}INPUTS@{ub} aucun @ENDNODE @NODE INACTIVEWINDOW "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} INACTIVEWINDOW -- désactiver une fenêtre @{b}SYNOPSIS@{ub} Label(INACTIVEWINDOW) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Veuillez utiliser @{"InstallEventHandler()" LINK InstallEventHandler} Hollywood utilisera la commande Gosub() pour effectuer un saut au label INACTIVEWINDOW afin de désactiver une fenêtre. Normalement vous n'avez pas besoin de cet événement, mais vous pouvez l'utiliser si vous voulez effectuer une tche quand votre fenêtre devient inactive. @{b}INPUTS@{ub} aucun @ENDNODE @NODE MOVEWINDOW "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} MOVEWINDOW -- tester si l'utilisateur a déplacé la fenêtre @{b}SYNOPSIS@{ub} Label(MOVEWINDOW) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Veuillez utiliser @{"InstallEventHandler()" LINK InstallEventHandler} Hollywood utilisera la commande Gosub() pour effectuer un saut au label MOVEWINDOW lorsque la fenêtre est déplacé, c'est utile pour connaître le moment ou votre fenêtre devient transparente. les fenêtres sont fermés et ouvert quand ils sont déplacés, donc vous serez peut être amené à retracer certains élément après que la fenêtre ait été déplacé. @{b}INPUTS@{ub} aucun @ENDNODE @NODE CLOSEWINDOW "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} CLOSEWINDOW -- tester si l'utilisateur à clicker sur le bouton fermeture de la fenêtre @{b}SYNOPSIS@{ub} Label(CLOSEWINDOW) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Veuillez utiliser @{"InstallEventHandler()" LINK InstallEventHandler}. Hollywood utilisera la commande Gosub() pour effectuer un saut au label CLOSEWINDOW lorsque l'utilisateur effectuera un clic sur le gadget de fermeture de la fenêtre. C'est utile si vous voulez ouvrir une requête et demander à l'utilisateur si il veux vraiment quitter votre application. @{b}INPUTS@{ub} aucun @ENDNODE @NODE SIZEWINDOW "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} SIZEWINDOW -- tester si l'utilisateur modifie la taille de la fenêtre @{b}SYNOPSIS@{ub} Label(SIZEWINDOW) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Veuillez utiliser @{"InstallEventHandler()" LINK InstallEventHandler}. Hollywood utilisera la commande Gosub() pour effectuer un saut au label SIZEWINDOW lorsque l'utilisateur modifierà la taille de la fenêtre. Si votre application supporte les fenêtres redimensionnables, vous devrez écrire un code après cette marque pour qu'il retrace/repositionne vos objets. @{b}INPUTS@{ub} aucun @ENDNODE @NODE WhileRightMouseDown "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} WhileRightMouseDown -- arrêter jusqu'à ce que le bouton de la souris droit soit relaché(V1.5) @{b}SYNOPSIS@{ub} WhileRightMouseDown() @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Utiliser les commandes de la nouvelle bibliothèque d'Hollywood 2.0 qui sont mieux exploités. Cette commande doit être exécuté après que se soit produit un événement ONBUTTONRIGHTCLICK. Si vous exécutez cette commande, Hollywood attendra jusqu'à ce que l'utilisateur ait terminé son clic de souris. Il est absolument nécessaire d'exécuter cette commande après que l'événement ONBUTTONRIGHTCLICK se soit produit parce que même si l'utilisateur effectue un seul clic avec la souris, plusieurs événements peuvent se produire. Afin d'éviter se genre de problème et de prendre en compte le bon événement généré, exécuter cette commande après ONBUTTONRIGHTCLICK. @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} voir le mot clé @{"%BUTTON" LINK BUTTON} @ENDNODE @NODE ONBUTTONRIGHTCLICK "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} ONBUTTONRIGHTCLICK -- tester si l'utilisateur effectue un clic droit (V1.5) @{b}SYNOPSIS@{ub} Label(ONBUTTONRIGHTCLICKx) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Utiliser les commandes de la nouvelle bibliothèque d'Hollywood 2.0 qui sont mieux exploités. Cet événement est généré quand l'utilisateur effectue un clic droit sur un bouton déclaré. Hollywood utilisera la commande Gosub() pour effectuer un saut au label ONBUTTONRIGHTCLICKx, @{b}x@{ub} étant l'id du bouton. Par exemple, Hollywood utiliserà la commande Gosub() pour effectuer un saut au label ONBUTTONRIGHTCLICK15 quand l'utilisateur appuie sur le bouton numéro 15. @{b}INPUTS@{ub} x - numéro de bouton @{b}EXEMPLE@{ub} voir le mot clé @{"%BUTTON" LINK BUTTON} @ENDNODE @NODE ONJOYUP "Guide Hollywood" @{b}NOM@{ub} ONJOYUP -- tester si l'utilisateur appuie vers le haut avec une manette de jeu (V1.5 - V1.9) @{b}SYNOPSIS@{ub} Label(ONJOYUPx) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Ce label n'est plus supporté depuis Hollywood 2.0. Cet événement est utilisé quand l'utilisateur déplace le manche de la manette dans le port @{b}x@{ub} vers le haut. @{b}INPUTS@{ub} x - numéro de port (habituellement 1 pour le port normal de la manette de jeu) @{b}EXEMPLE@{ub} While(quit = FALSE) WaitEvent Wend Label(ONJOYUP1) NPrint("Manette orientée : Haut") Return Label(ONJOYUPRIGHT1) NPrint("Manette orientée : Haut/Droite") Return Label(ONJOYRIGHT1) NPrint("Manette orientée : Droite") Return Label(ONJOYDOWNRIGHT1) NPrint("Manette orientée : Bas/Droite") Return Label(ONJOYDOWN1) NPrint("Manette orientée : Bas") Return Label(ONJOYDOWNLEFT1) NPrint("Manette orientée : Bas/Gauche") Return Label(ONJOYLEFT1) NPrint("Manette orientée : Gauche") Return Label(ONJOYUPLEFT1) NPrint("Manette orientée : Haut/Gauche") Return Label(ONJOYFIRE1) NPrint("Bouton Feu") Return Le code ci-dessus montre comment questionner l'entrée de la manette de jeu. @ENDNODE @NODE ONJOYUPRIGHT "Guide Hollywood" @{b}NOM@{ub} ONJOYUPRIGHT -- tester si l'utilisateur a déplacé la manette de jeux vers: haut/droite (V1.5 - V1.9) @{b}SYNOPSIS@{ub} Label(ONJOYUPRIGHTx) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Ce label n'est plus supporté depuis Hollywood 2.0. Cet événement est utilisé quand l'utilisateur déplace la manette de jeu branché dans le port @{b}x@{ub} vers haut/droite. @{b}INPUTS@{ub} x - numéro de port (habituellement 1 pour le port normal de la manette de jeu) @{b}EXEMPLE@{ub} voir @{"ONJOYUP" LINK ONJOYUP} @ENDNODE @NODE ONJOYRIGHT "Guide Hollywood" @{b}NOM@{ub} ONJOYRIGHT -- tester si l'utilisateur a déplacé la manette de jeux vers: Droite (V1.5 - V1.9) @{b}SYNOPSIS@{ub} Label(ONJOYRIGHTx) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Ce label n'est plus supporté depuis Hollywood 2.0. Cet événement est utilisé quand l'utilisateur déplace la manette de jeu branché dans le port @{b}x@{ub} vers droite. @{b}INPUTS@{ub} x - numéro de port (habituellement 1 pour le port normal de la manette de jeu) @{b}EXEMPLE@{ub} voir @{"ONJOYUP" LINK ONJOYUP} @ENDNODE @NODE ONJOYDOWNRIGHT "Guide Hollywood" @{b}NOM@{ub} ONJOYDOWNRIGHT -- tester si l'utilisateur a déplacé la manette de jeux vers: Bas/Droite (V1.5 - V1.9) @{b}SYNOPSIS@{ub} Label(ONJOYDOWNRIGHTx) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Ce label n'est plus supporté depuis Hollywood 2.0. Cet événement est utilisé quand l'utilisateur déplace la manette de jeu branché dans le port @{b}x@{ub} vers Bas/Droite. @{b}INPUTS@{ub} x - numéro de port (habituellement 1 pour le port normal de la manette de jeu) @{b}EXEMPLE@{ub} voir @{"ONJOYUP" LINK ONJOYUP} @ENDNODE @NODE ONJOYDOWN "Guide Hollywood" @{b}NOM@{ub} ONJOYDOWN -- tester si l'utilisateur a déplacé la manette de jeux vers: Bas (V1.5 - V1.9) @{b}SYNOPSIS@{ub} Label(ONJOYDOWNx) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Ce label n'est plus supporté depuis Hollywood 2.0. Cet événement est utilisé quand l'utilisateur déplace la manette de jeu branché dans le port @{b}x@{ub} vers Bas. @{b}INPUTS@{ub} x - numéro de port (habituellement 1 pour le port normal de la manette de jeu) @{b}EXEMPLE@{ub} voir @{"ONJOYUP" LINK ONJOYUP} @ENDNODE @NODE ONJOYDOWNLEFT "Guide Hollywood" @{b}NOM@{ub} ONJOYDOWNLEFT -- tester si l'utilisateur a déplacé la manette de jeux vers: Bas/Gauche (V1.5 - V1.9) @{b}SYNOPSIS@{ub} Label(ONJOYDOWNLEFTx) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Ce label n'est plus supporté depuis Hollywood 2.0. Cet événement est utilisé quand l'utilisateur déplace la manette de jeu branché dans le port @{b}x@{ub} vers Bas/Gauche. @{b}INPUTS@{ub} x - numéro de port (habituellement 1 pour le port normal de la manette de jeu) @{b}EXEMPLE@{ub} voir @{"ONJOYUP" LINK ONJOYUP} @ENDNODE @NODE ONJOYLEFT "Guide Hollywood" @{b}NOM@{ub} ONJOYLEFT -- tester si l'utilisateur a déplacé la manette de jeux vers: Gauche (V1.5 - V1.9) @{b}SYNOPSIS@{ub} Label(ONJOYLEFTx) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Ce label n'est plus supporté depuis Hollywood 2.0. Cet événement est utilisé quand l'utilisateur déplace la manette de jeu branché dans le port @{b}x@{ub} vers Gauche. @{b}INPUTS@{ub} x - numéro de port (habituellement 1 pour le port normal de la manette de jeu) @{b}EXEMPLE@{ub} voir @{"ONJOYUP" LINK ONJOYUP} @ENDNODE @NODE ONJOYUPLEFT "Guide Hollywood" @{b}NOM@{ub} ONJOYUPLEFT -- tester si l'utilisateur a déplacé la manette de jeux vers: Haut/Gauche (V1.5 - V1.9) @{b}SYNOPSIS@{ub} Label(ONJOYUPLEFTx) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Ce label n'est plus supporté depuis Hollywood 2.0. Cet événement est utilisé quand l'utilisateur déplace la manette de jeu branché dans le port @{b}x@{ub} vers Haut/Gauche. @{b}INPUTS@{ub} x - numéro de port (habituellement 1 pour le port normal de la manette de jeu) @{b}EXEMPLE@{ub} voir @{"ONJOYUP" LINK ONJOYUP} @ENDNODE @NODE ONJOYFIRE "Guide Hollywood" @{b}NOM@{ub} ONJOYFIRE -- tester si l'utilisateur a appuyé sur le bouton Feu de la manette de jeu (V1.5 - V1.9) @{b}SYNOPSIS@{ub} Label(ONJOYFIREx) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Ce label n'est plus supporté depuis Hollywood 2.0. Cet événement est utilisé quand l'utilisateur appui sur le bouton Feu de la manette de jeu brancher dans le port @{b}x@{ub}. @{b}INPUTS@{ub} x - numéro de port (habituellement 1 pour le port normal de la manette de jeu) @{b}EXEMPLE@{ub} voir @{"ONJOYUP" LINK ONJOYUP} @ENDNODE @NODE ONBUTTONCLICKALL "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} ONBUTTONCLICKALL -- tester si l'utilisateur à cliquer sur un bouton (V1.5) @{b}SYNOPSIS@{ub} Label(ONBUTTONCLICKALL) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Utiliser les commandes de la nouvelle bibliothèque d'Hollywood 2.0 qui sont mieux exploités. Si vous spécifiez cet événement et qu'il est activé, Hollywood sautera toujours à ce label quand il obtiendra un événement @{"ONBUTTONCLICK" LINK ONBUTTONCLICK}. Si vous voulez connaître quel bouton active le saut de label, utiliser @{"GetEventCode()" LINK GetEventCode}. Il renverra quel bouton a entraîné cet événement. Cet événement est très utile si vous avez par exemple 100 boutons ou plus et que chaque bouton effectue un saut @{"Gosub()" LINK Gosub} à une sous-routine qui reçoit une id du bouton actionnée. Au lieu de définir 100 labels, vous pouvez juste utiliser ONBUTTONCLICKALL avec @{"GetEventCode()" LINK GetEventCode}. Par exemple, si vous avez 3 boutons avec l'id de 1 à 3, Hollywood exécuterait un saut à ONBUTTONCLICK1, ONBUTTONCLICK2 ou ONBUTTONCLICK3 si un de ces boutons était actionné. Mais si vous définissez un événement ONBUTTONCLICKALL dès qu'un bouton sera actionné, Hollywood sautera toujour au même label. @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} %BUTTON(1) = 10 / 10 / 100 / 100 %BUTTON(2) = 130 / 130 / 230 / 230 %BUTTON(3) = 260 / 260 / 360 / 360 %KEYDOWN(1) = "F1" %KEYDOWN(2) = "F2" %KEYDOWN(3) = "F3" While(quit = FALSE) WaitEvent Wend Label(ONBUTTONCLICKALL) WhileMouseDown id = GetEventCode() Print("L'utilisateur a effectué un clic gauche sur le button # ") Print(id) Return Label(ONBUTTONRIGHTCLICKALL) WhileRightMouseDown id = GetEventCode() Print("L'utilisateur a effectué un clic droit sur le button # ") Print(id) Return Label(ONBUTTONOVERALL) WhileMouseOn id = GetEventCode() Print("L'utilisateur a bougé la souris sur le button # ") Print(id) Return Label(ONKEYDOWNALL) WhileKeyDown id = GetEventCode() Print("L'utilisateur a appuyé sur la touche # ") Print(id) Return Le code ci-dessus utilise TOUS LES événements spéciaux avec GetEventCode() pour découvrir quels boutons active quels événements. @ENDNODE @NODE ONBUTTONRIGHTCLICKALL "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} ONBUTTONRIGHTCLICKALL -- tester si l'utilisateur fait un clic droit sur n'importe quels boutons (V1.5) @{b}SYNOPSIS@{ub} Label(ONBUTTONRIGHTCLICKALL) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Utiliser les commandes de la nouvelle bibliothèque d'Hollywood 2.0 qui sont mieux exploités. Si vous spécifiez cet événement et qu'il est activé, Hollywood sautera toujours à ce label quand il obtient un événement @{"ONBUTTONRIGHTCLICK" LINK ONBUTTONRIGHTCLICK}. Si vous voulez connaître quel bouton active le saut de label, utiliser @{"GetEventCode()" LINK GetEventCode}. Il renverra quel bouton a entraîné cet événement. Cet événement est très utile si vous avez par exemple 100 boutons ou plus et que chaque bouton effectue un saut @{"Gosub()" LINK Gosub} à une sous-routine qui reçoit une id du bouton actionnée. Au lieu de définir 100 labels, vous pouvez juste utiliser ONBUTTONCLICKALL avec @{"GetEventCode()" LINK GetEventCode}. @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} voir @{"ONBUTTONCLICKALL" LINK ONBUTTONCLICKALL} @ENDNODE @NODE ONBUTTONOVERALL "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} ONBUTTONOVERALL -- tester si l'utilisateur a déplacé la souris au-dessus de n'importe quel bouton (V1.5) @{b}SYNOPSIS@{ub} Label(ONBUTTONOVERALL) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Utiliser les commandes de la nouvelle bibliothèque d'Hollywood 2.0 qui sont mieux exploités. Si vous spécifiez cet événement et qu'il est activé, Hollywood sautera toujours à ce label quand il obtient un événement @{"ONBUTTONOVER" LINK ONBUTTONOVER}. Si vous voulez savoir, quel bouton entraîne le saut de label, utiliser @{"GetEventCode()" LINK GetEventCode}. Il renverra quel bouton a entraîné cet événement. Cet événement est très utile si vous avez par exemple 100 boutons ou plus et que chaque bouton effectue un saut @{"Gosub()" LINK Gosub} à une sous-routine qui reçoit une id du bouton actionnée. Au lieu de définir 100 labels, vous pouvez juste utiliser ONBUTTONCLICKALL avec @{"GetEventCode()" LINK GetEventCode}. @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} voir @{"ONBUTTONCLICKALL" LINK ONBUTTONCLICKALL} @ENDNODE @NODE ONKEYDOWNALL "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} ONKEYDOWNALL -- tester si l'utilisateur a appuyé sur une touche (V1.5) @{b}SYNOPSIS@{ub} Label(ONKEYDOWNALL) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Utiliser les commandes de la nouvelle bibliothèque d'Hollywood 2.0 qui sont mieux exploités. Si vous spécifiez cet événement et qu'il est activé, Hollywood sautera toujours à ce label quand il obtient un événement @{"ONKEYDOWN" LINK ONKEYDOWN}. Si vous voulez savoir, quel touche entraîne le saut de label, utiliser @{"GetEventCode()" LINK GetEventCode}. Il renverra quel touche a entraîné cet événement. Cet événement est très utile si vous avez par exemple 100 boutons ou plus et que chaque bouton effectue un saut @{"Gosub()" LINK Gosub} à une sous-routine qui reçoit une id du bouton actionnée. Au lieu de définir 100 labels, vous pouvez juste utiliser ONBUTTONCLICKALL avec @{"GetEventCode()" LINK GetEventCode}. @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} voir @{"ONBUTTONCLICKALL" LINK ONBUTTONCLICKALL} @ENDNODE @NODE GetEventCode "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} GetEventCode -- obtenir le code de l'évenement (V1.5) @{b}SYNOPSIS@{ub} code= GetEventCode() @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Utiliser les commandes de la nouvelle bibliothèque d'Hollywood 2.0 qui sont mieux exploités. Cette commande est a utilisé bien après un saut de label d'événement. Si un événement peut vous indiquer des informations complémentaires, vous pouvez les obtenir avec cette commande. Par exemple, @{"ONBUTTONCLICKALL" LINK ONBUTTONCLICKALL} renvoie l'id du bouton qui effectue un saut de label. @{b}INPUTS@{ub} aucun @{b}RESULTATS@{ub} id - indicateur d'événement @{b}EXEMPLE@{ub} voir @{"ONBUTTONCLICKALL" LINK ONBUTTONCLICKALL} @ENDNODE @NODE ClearEvents "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} ClearEvents -- libérer tous les événements (V1.5) @{b}SYNOPSIS@{ub} ClearEvents() @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Utiliser les commandes de la nouvelle bibliothèque d'Hollywood 2.0 qui sont mieux exploités. Cette commande libère tous les événements. @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} %BUTTON(1) = 10 / 10 / 110 / 110 %BUTTON(2) = 130 / 130 / 230 / 230 %KEYDOWN(1) = "ESC" %CODE ClearEvents End Label(SIZEWINDOW) Return Label(ONJOYFIRE1) Return Label(CLOSEWINDOW) Return Le code ci-dessus définit quelques événements et appelle ClearEvents(). Cette commande libère les événements suivants : Bouton 1, bouton 2 et Keydown 1. Les événements SIZEWINDOW, ONJOYFIRE1 et CLOSEWINDOW ne seront pas libérés puisqu'ils sont seulement déclarés en tant que labels. Si vous voulez vous débarrasser d'elles, vous pouvez les désactiver. @ENDNODE @NODE WhileKeyDown "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} WhileKeyDown -- arrêter jusqu'à ce que la touche soit relevé (V1.5) @{b}SYNOPSIS@{ub} WhileKeyDown() @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Utiliser les commandes de la nouvelle bibliothèque d'Hollywood 2.0 qui sont mieux exploités. Cette commande peut être utilisé avec @{"ONKEYDOWN" LINK ONKEYDOWN} après qu'un événement se soit produit. Si vous appelez cette commande, Hollywood attendra jusqu'à ce que l'utilisateur relche la touche qui a entraîné l'événement. Si vous n'appelez pas cette commande après votre label (ONKEYDOWNx), vous pouvez recevoir plusieurs événements si l'utilisateur maintient la touche plus longtemps. @{b}INPUTS@{ub} aucun @ENDNODE @NODE BreakWhileMouseOn "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} BreakWhileMouseOn -- briser la prochaine commande de WhileMouseOn (V1.9) @{b}SYNOPSIS@{ub} BreakWhileMouseOn() @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Utiliser les commandes de la nouvelle bibliothèque d'Hollywood 2.0 qui sont mieux exploités. Cette commande brise la prochaine commande @{"WhileMouseOn()" LINK WhileMouseOn} qui sera effectué. Vous utiliserez habituellement cette commande si votre label ONBUTTONCLICK retourne immédiatement à votre boucle d'événement au lieu de retourner à la commande WhileMouseOn() dans votre label ONBUTTONOVER. Si vous avez un événement ONBUTTONCLICK et un label ONBUTTONOVER, Hollywood reviendra à votre label ONBUTTONOVER après que le bouton de la souris est été relché parce que la souris est toujours au-dessus de votre bouton après que l'utilisateur ai cliqué avec la souris. Si vous voulez que Hollywood retourne à votre boucle principale d'événement après un clique de souris, utiliser cette commande. Note : Cette commande est seulement utilisée dans de rares cas. @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} While(quit = FALSE) WaitEvent Wend Label(ONBUTTONOVER1) Print(" La souris est au-dessus du bouton 1 ") WhileMouseOn Print(" La souris n'est plus au-dessus du bouton 1 ") Label(ONBUTTONCLICK1) Print(" clique de souris sur le bouton 1 ") WhileMouseDown Print(" bouton de la souris relché ") BreakWhileMouseOn Return Lire le code ci-dessus. BreakWhileMouseOn() demande à Hollywood de retourner immédiatement à la boucle de WaitEvent(). Si il n'y avait pas la commande BreakWhileMouseOn() dans le code ci-dessus, Hollywood reviendrait à la commande WhileMouseOn() et mettrai le code en attente jusqu'à se que l'utilisateur déplace la souris hors de l'emplacement du bouton. @ENDNODE @NODE Gosub "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} Gosub -- appeler une sous-routine @{b}SYNOPSIS@{ub} Gosub(label) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Veuillez utiliser les @{"fonctions" LINK V6PrgFunctions} au lieu des labels. Cette commande saute à la sous-routine spécifiée par le label. la sous-routine peut appeler @{"Return()" LINK Return} pour retourner au point d'où elle a été appelé. @{b}INPUTS@{ub} label - identificateur pour un label (définie avec @{"Label()" LINK Label}) @{b}EXEMPLE@{ub} a$="Hello World" Gosub(PRINTTEXT) WaitLeftMouse End Label(PRINTTEXT) Print(a$) Return Le code ci-dessus affiche le texte "Hello World" sur l'écran et attend un clic sur le bouton gauche de la souris. Puis quitte l'application. @ENDNODE @NODE Goto "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} Goto -- sauter à un nouvel emplacement @{b}SYNOPSIS@{ub} Goto(label) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Veuillez utiliser les @{"fonctions" LINK V6PrgFunctions} au lieu des labels. Cette commande saute à l'emplacement spécifié par le label. L'exécution continue ici et il n'est pas possible de revenir au point d'où le label a été appelée. Si vous avez besoin de revenir, utiliser la commande @{"Gosub()" LINK Gosub}. @{b}INPUTS@{ub} label - identificateur pour un label (définie avec @{"Label()" LINK Label}) @{b}EXEMPLE@{ub} a$="Hello World" Goto(PRINTTEXT) WaitLeftMouse ; cet commande ne sera jamais atteint End ; Label(PRINTTEXT) Print(a$) WaitLeftMouse End Le code ci-dessus affiche le texte "Hello World" sur l'écran et attend un clic sur le bouton gauche de la souris. @ENDNODE @NODE Label "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} Label -- déclarer un nouveau label @{b}SYNOPSIS@{ub} Label(name) @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Veuillez utiliser les @{"fonctions" LINK V6PrgFunctions} au lieu des labels. Cette commande déclare un nouveau label avec le nom spécifié. Vous pouvez sauter à se label avec les commandes @{"Gosub()" LINK Gosub} et @{"Goto()" LINK Goto}. Veuillez noter que le nom n'est pas une chaîne de caractères. Vous devez spécifier un nom de variable qui sera utilisé comme référence pour ce label. @{b}INPUTS@{ub} name - identificateur à utiliser @{b}EXEMPLE@{ub} voir @{"Gosub()" LINK Gosub} voir @{"Goto()" LINK Goto} @ENDNODE @NODE Return "Guide Hollywood" @{APEN 4}@{B}COMMANDE OBSOLETE -----------------@{UB}@{APEN 1} @{b}NOM@{ub} Return -- retourner au dernier Gosub @{b}SYNOPSIS@{ub} Return() @{b}FONCTION@{ub} @{APEN 4}ATTENTION:@{APEN 1} Cette commande fait partie de la bibliothèque d'événement d'Hollywood 1.x. Vous ne devez plus l'utiliser. Veuillez utiliser les @{"fonctions" LINK V6PrgFunctions} au lieu des labels. Cette commande retournera au point où le dernier sous-programme à effectué un gosub. @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} voir @{"Gosub()" LINK Gosub} @ENDNODE @NODE V6LibEventCompat "Guide Hollywood" @{APEN 16} @{b}Evénements sous Hollywood 1.x@{ub} @{APEN 1} @{b}Note:@{ub} ce chapitre est inclus pour obtenir seulement des informations. Toutes les commandes/mots clés/gestionnaires d'événement indiqués ici sont @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} et ne doivent plus être utilisé. Veuillez utiliser les fonctions de la @{"nouvelle bibliothèque d'événement" LINK V6LibEvent}. Un [E] indique que Hollywood 2.0 [e]mule cette caractéristique, [D] indique que cette caractéristique à été enlevé et ne peut plus être utilisée. @{APEN 16} @{b}1. Déclaration d'événements@{ub}@{APEN 1} @{"%BUTTON keyword " LINK BUTTON} Déclarer un bouton [E] @{"%KEYDOWN keyword " LINK KEYDOWN} Déclarer une touche [E] @{APEN 16} @{b}2. Labels@{ub}@{APEN 1} @{"Gosub() " LINK Gosub } appeler une sous-routine [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"Goto() " LINK Goto } sauter à un nouvel emplacement [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"Label() " LINK Label } déclarer un nouveau label [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"Return() " LINK Return } retourner au dernier Gosub() [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{APEN 16} @{b}3. Utilisation des événements@{ub}@{APEN 1} @{"BreakWhileMouseOn() " LINK BreakWhileMouseOn } arrêter jusqu'à ce que l'utilisateur déplace la souris hors d'un bouton [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"CheckEvent() " LINK CheckEvent } vérifier rapidement les événements (V1.9 - V2.0) [D] @{"ClearEvents() " LINK ClearEvents } libérer tous les événements (V1.5) [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"CreateButton() " LINK CreateButton } Créer un nouveau bouton [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"CreateKeyDown() " LINK CreateKeyDown } créer un nouvel objet keydown [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"DisableEvent() " LINK DisableEvent } désactiver un événement [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"DisableEventHandler() " LINK DisableEventHandler } désactiver le gestionnaire d'événement Hollywood (V1.0 - V1.5) [D] @{"EnableEvent() " LINK EnableEvent } activer un événement [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"EnableEventHandler() " LINK EnableEventHandler } activer le gestionnaire d'événement d'Hollywood (V1.0 - V1.5) [D] @{"GetEventCode() " LINK GetEventCode } obtenir le code de l'évenement (V1.5) [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"ModifyButton() " LINK ModifyButton } modifier les caractéristiques d'un bouton [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"ModifyKeyDown() " LINK ModifyKeyDown } modifier les caractéristiques d'objet de keydown [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"RemoveButton() " LINK RemoveButton } retirer un bouton [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"RemoveKeyDown() " LINK RemoveKeyDown } enlever un objet de keydown [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"WhileKeyDown() " LINK WhileKeyDown } arrêter jusqu'à ce que la touche soit relevé (V1.5) [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"WhileMouseDown() " LINK WhileMouseDown } arrêter jusqu'à ce que le bouton de la souris soit relché [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"WhileMouseOn() " LINK WhileMouseOn } arrêter jusqu'à ce que l'utilisateur déplace la souris hors d'un bouton [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"WhileRightMouseDown() " LINK WhileRightMouseDown } arrêter jusqu'à ce que le bouton de la souris droit soit relaché (V1.5) [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{APEN 16} @{b}4. Evénements@{ub}@{APEN 1} @{"ACTIVEWINDOW " LINK ACTIVEWINDOW } activer une fenêtre [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"CLOSEWINDOW " LINK CLOSEWINDOW } tester si l'utilisateur à clicker sur le bouton fermeture fenêtre [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"INACTIVEWINDOW " LINK INACTIVEWINDOW } désactiver une fenêtre [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"MOVEWINDOW " LINK MOVEWINDOW } tester si l'utilisateur a déplacé la fenêtre [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"ONBUTTONCLICK " LINK ONBUTTONCLICK } utiliser le clic d'un bouton [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"ONBUTTONCLICKALL " LINK ONBUTTONCLICKALL } tester si l'utilisateur à cliquer sur n'importe quel bouton (V1.5) [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"ONBUTTONOVER " LINK ONBUTTONOVER } Tester si le pointeur de la souris passe au-dessus d'un bouton [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"ONBUTTONOVERALL " LINK ONBUTTONOVERALL } tester si 'utilisateur a déplacé la souris au-dessus de n'importe quel bouton (V1.5) [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"ONBUTTONRIGHTCLICK " LINK ONBUTTONRIGHTCLICK } tester si l'utilisateur effectue un clic droit (V1.5) [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"ONBUTTONRIGHTCLICKALL " LINK ONBUTTONRIGHTCLICKALL} tester si l'utilisateur fait un clic droit sur n'importe quels boutons (V1.5) [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"ONJOYDOWN " LINK ONJOYDOWN } tester si l'utilisateur a déplacé le manche vers : Bas (V1.5 - V1.9) [D] @{"ONJOYDOWNLEFT " LINK ONJOYDOWNLEFT } tester si l'utilisateur a déplacé le manche vers : Bas/Gauche (V1.5 - V1.9) [D] @{"ONJOYDOWNRIGHT " LINK ONJOYDOWNRIGHT } tester si l'utilisateur a déplacé le manche vers : Bas/Droite (V1.5 - V1.9) [D] @{"ONJOYFIRE " LINK ONJOYFIRE } tester si l'utilisateur a appuyé sur le bouton Feu de la manette de jeu (V1.5 - V1.9) [D] @{"ONJOYLEFT " LINK ONJOYLEFT } tester si l'utilisateur a déplacé le manche vers : Gauche (V1.5 - V1.9) [D] @{"ONJOYRIGHT " LINK ONJOYRIGHT } tester si l'utilisateur a déplacé le manche vers : Droite (V1.5 - V1.9) [D] @{"ONJOYUP " LINK ONJOYUP } tester si l'utilisateur appuie vers le haut avec une manette de jeu (V1.5 - V1.9) [D] @{"ONJOYUPLEFT " LINK ONJOYUPLEFT } tester si l'utilisateur a déplacé le manche vers : Haut/Gauche (V1.5 - V1.9) [D] @{"ONJOYUPRIGHT " LINK ONJOYUPRIGHT } tester si l'utilisateur a déplacé le manche vers : haut/droite (V1.5 - V1.9) [D] @{"ONKEYDOWN " LINK ONKEYDOWN } Tester si l'utilisateur a appuyé sur une touche [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"ONKEYDOWNALL " LINK ONKEYDOWNALL } tester si l'utilisateur a appuyé sur une touce (V1.5) [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"SIZEWINDOW " LINK SIZEWINDOW } tester si l'utilisateur modifie la taille de la fenêtre [E] @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @ENDNODE @NODE IsLeftMouse "Guide Hollywood" @{b}NOM@{ub} IsLeftMouse -- vérifier si le bouton gauche de la souris est actionné @{b}SYNOPSIS@{ub} pressed=IsLeftMouse() @{b}FONCTION@{ub} Cette commande renvoie TRUE si le bouton gauche de la souris est actionné sinon False. @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} Repeat Wait(2) Until IsLeftMouse() = True Le code ci-dessus attend jusqu'à ce que le bouton gauche de la souris soit actionné (vous pouvez obtenir plus facilement cette action en utilisant @{"WaitLeftMouse()" LINK WaitLeftMouse}; le code ci-dessus est seulement utile si vous voulez faire quelque chose alors que le bouton de la souris n'est pas appuyé). @ENDNODE @NODE WaitLeftMouse "Guide Hollywood" @{b}NOM@{ub} WaitLeftMouse -- attendre que l'utilisateur actionne le bouton gauche de la souris @{b}SYNOPSIS@{ub} WaitLeftMouse () @{b}FONCTION@{ub} Cette commande maintient l'exécution du script jusqu'à ce que le bouton gauche de la souris soit actionné. @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} Print(" Appuyer sur le bouton gauche de la souris pour quitter.") WaitLeftMouse End Attend que l'utilisateur actionne le bouton gauche de la souris. @ENDNODE @NODE MouseX "Guide Hollywood" @{b}NOM@{ub} MouseX -- connaître la position x de la souris (V1.5) @{b}SYNOPSIS@{ub} pos=MouseX() @{b}FONCTION@{ub} Cette commande renvoie la position x du pointeur de la souris. @{b}INPUTS@{ub} aucun @{b}RESULTATS@{ub} pos - position x du pointeur de la souris @ENDNODE @NODE MouseY "Guide Hollywood" @{b}NOM@{ub} MouseY -- connaître la position y de la souris (V1.5) @{b}SYNOPSIS@{ub} pos=MouseY() @{b}FONCTION@{ub} Cette commande renvoie la position y du pointeur de la souris. @{b}INPUTS@{ub} aucun @{b}RESULTATS@{ub} pos - position y du pointeur de la souris @ENDNODE @NODE IsRightMouse "Guide Hollywood" @{b}NOM@{ub} IsRightMouse -- vérifier si le bouton droit de la souris est actionné (V1.5) @{b}SYNOPSIS@{ub} pressed=IsRightMouse() @{b}FONCTION@{ub} Cette commande renvoie TRUE si le bouton droit de la souris est actionné sinon FALSE. @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} Repeat Wait(2) Until IsRightMouse() = True Le code ci-dessus attend jusqu'à ce que le bouton droit de la souris soit actionné. (vous pouvez obtenir plus facilement cette action en utilisant @{"WaitRightMouse()" LINK WaitRightMouse}; le code ci-dessus est seulement utile si vous voulez faire quelque chose alors que le bouton de la souris n'est pas appuyé). @ENDNODE @NODE WaitRightMouse "Guide Hollywood" @{b}NOM@{ub} WaitRightMouse -- attendre que l'utilisateur actionne le bouton droit de la souris (V1.5) @{b}SYNOPSIS@{ub} WaitRightMouse() @{b}FONCTION@{ub} Cette commande maintient l'exécution du script jusqu'à ce que le bouton gauche de la souris soit actionné. @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} Print(" Appuyer sur le bouton droit de la souris pour quitter.") WaitRightMouse End Attend que l'utilisateur actionne le bouton droit de la souris. @ENDNODE @NODE JoyDir "Guide Hollywood" @{b}NOM@{ub} JoyDir -- connaître la direction de la manette de jeux (V1.5) @{b}SYNOPSIS@{ub} dir = JoyDir(port) @{b}FONCTION@{ub} Cette commande renvoie la direction de la manette de jeux branché sur le port spécifié par @{b}port@{ub}. Une des conditions suivantes sera retournée : #JOYUP - la direction est vers Haut #JOYUPRIGHT - la direction est vers Haut/Droit #JOYRIGHT - la direction est vers Droite #JOYDOWNRIGHT - la direction est vers Bas/Droite #JOYDOWN - la direction est vers Bas #JOYDOWNLEFT - la direction est vers Bas/Gauche #JOYLEFT - la direction est vers gauche #JOYUPLEFT - la direction est vers Gauche/Haut #JOYNODIR - aucun sens sélectionné Le port est 0 (port souris) ou 1 pour le port normal de la manette de jeu. @{b}INPUTS@{ub} port - numéro de port (habituellement 1 pour le port normal de la manette de jeux) @{b}RESULTATS@{ub} dir - direction actionné sur la manette de jeu (comme indiqué ci-dessus) @{b}EXEMPLE@{ub} While(state <> #JOYRIGHT) state = JoyDir(1) Wait(2) Wend Le code ci-dessus attend jusqu'à ce que l'utilisateur actionne la manette de jeu dans le port 1 en direction de la droite. @ENDNODE @NODE JoyFire "Guide Hollywood" @{b}NOM@{ub} JoyFire -- vérifier si le bouton Feu de la manette de jeux est actionné (V1.5) @{b}SYNOPSIS@{ub} fire = JoyFire(port) @{b}FONCTION@{ub} Cette commande renvoie TRUE si la manette de jeux branchait au port spécifié par @{b}port@{ub} a le bouton Feu d'actionné. Sinon FALSE sera retourné. port peut être a 0 (port souris) ou 1 pour le port normal de la manette de jeu. @{b}INPUTS@{ub} port - numéro de port (habituellement 1 pour le port normal de la manette de jeu) @{b}RESULTATS@{ub} fire - TRUE si le bouton Feu est actionné, sinon FALSE @{b}EXEMPLE@{ub} While(fire = FALSE) fire = JoyFire(1) Wait(2) Wend Le code ci-dessus attend jusqu'à ce que l'utilisateur actionne le bouton Feu de la manette de jeux. @ENDNODE @NODE CheckEvent "Guide Hollywood" @{b}NOM@{ub} CheckEvent -- vérifier rapidement les événements (V1.9 - V2.0) @{b}SYNOPSIS@{ub} CheckEvent() @{b}FONCTION@{ub} Attention : Cette commande n'est plus compatible avec Hollywood 2.5. Utiliser @{"WaitEvent()" LINK WaitEvent} Cette commande vérifie rapidement s'il y a des événements à traiter. Si c'est le cas, CheckEvent() sautera aux labels d'événement pour que votre code puisse les traiter. S'il n'y a aucun événement, CheckEvent() s'arrêtera et l'exécution du script continuera. Cette commande est assimilée à la commande @{"WaitEvent()" LINK WaitEvent} avec la différence que WaitEvent() bloque l'exécution du script jusqu'à ce qu'un événement intervienne et qu'il s'arrête immédiatement s'il n'y a aucun événement. En utilisant cette commande vous pouvez faire quelque chose tout en attendant un événement, se qui ne serait pas possible avec WaitEvent(). Depuis Hollywood 2.0: Vous ne devez plus utiliser cette commande, utiliser WaitEvent() avec @{"SetInterval()" LINK SetInterval}. @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} EnableLayers While(quit = FALSE) CheckEvent If(reverse = FALSE) x = x + 3 Else x = x - 3 EndIf If(x >= 640) x = x - 3 reverse = TRUE ElseIf(x <= 0) x = x + 3 reverse = FALSE EndIf AddMove(1, #BRUSH, 1, x, #CENTER) DoMove(1) ClearMove(1) Wend Le code ci-dessus bouge la brosse 1 de gauche à droite et de droite à gauche et attent qu'un événement se produise. Par exemple, si vous avez un menu principal dans votre jeu et que vous voulez afficher quelques images tout en attendant que l'utilisateur actionne le bouton Feu, CheckEvent() est la commande à utiliser. @ENDNODE @NODE WaitKeyDown "Guide Hollywood" @{b}NOM@{ub} WaitKeyDown -- attendre que l'utilisateur appui sur une touche (V1.5) @{b}SYNOPSIS@{ub} WaitKeyDown(key$) @{b}FONCTION@{ub} Cette commande arrête l'exécution du programme jusqu'à ce que l'utilisateur appuie sur la touche spécifié par @{b}key$@{ub}. Veuillez voir la documentation de la commande @{"IsKeyDown()" LINK IsKeyDown} pour connaître les touches que vous pouvez indiquer dans @{b}key$@{ub}. Noter que WaitKeyDown() ne peut pas tester les touches ALT, shift, commande, et les touches contrôle (Ctrl). @{b}INPUTS@{ub} key$ - touche à attendre @{b}EXEMPLE@{ub} Print("Appuyer sur Return pour continuer.") WaitKeyDown("Return") Les code ci-dessus attend jusqu'à ce que l'utilisateur appui sur la touche Return. @ENDNODE @NODE IsKeyDown "Guide Hollywood" @{b}NOM@{ub} IsKeyDown -- vérifier si une touche est actionnée (V1.5) @{b}SYNOPSIS@{ub} state = IsKeyDown(key$) @{b}FONCTION@{ub} Cette commande contrôle si la touche spécifié par key$ est actionnée. Si elle l'est, Cette commande renverra TRUE sinon elle retournera FALSE. @{b}Key$@{ub} est une chaîne représentant une touche sur votre clavier. Celle-ci peut être un des contrôle de touches suivants : "UP" - curseur vers le Haut "DOWN" - curseur vers le Bas "RIGHT" - curseur vers la Droite "LEFT" - curseur vers la Gauche "HELP" - touche Help "DEL" - touche Del "BACKSPACE" - touche Backspace "TAB" - touche Tab "RETURN" - touche Return "ENTER" - touche Enter "ESC" - touche Esc "SPACE" - touche Espace "F1 - F16" - touche de fonction "INSERT" - touche Insert "HOME" - touche Home "END" - touche End "PAGEUP" - touche PageUp "PAGEDOWN" - touche PageDown "PRINT" - touche Print "PAUSE" - touche Pause Les autres touches peuvent être déclarées en spécifiant juste le caractère de la touche dans la chaîne de caractères, par exemple "A", "!" ou "-". Depuis Hollywood 4.0, vous pouvez également vérifier les touches spéciales. Les touches suivantes peuvent être contrôlées en utilisant IsKeyDown(): "LSHIFT" - touche Shift Gauche "RSHIFT" - touche Shift Droit "LALT" - touche Alt Gauche "RALT" - touche Alt Droit "LCOMMAND" - touche Command Gauche "RCOMMAND" - touche Command Droit "LCONTROL" - touche Contrôle Gauche "RCONTROL" - touche Contrôle Droit @{b}INPUTS@{ub} key$ - touche à vérifier @{b}RESULTATS@{ub} state - TRUE si key$ est actionné, sinon FALSE @{b}EXEMPLE@{ub} Print("Appuyer sur F1.") Repeat Wait(2) Until IsKeyDown("F1") = True Le code ci-dessus attend jusqu'à ce que la touche F1 soit actionnée. (vous pouvez obtenir plus facilement cette action en utilisant @{"WaitKeyDown()" LINK WaitKeyDown}; le code au-dessus est seulement utile si vous voulez faire quelque chose tandis que la touche n'est pas actionné) @ENDNODE @NODE InKeyStr "Guide Hollywood" @{b}NOM@{ub} InKeyStr -- lire l'entrée du clavier de l'utilisateur (V1.5) @{b}SYNOPSIS@{ub} input$ = InKeyStr(type[, maxlen, password]) @{b}FONCTION@{ub} Cette commande vous permet de récupérer facilement la saisie des caractères que l'utilisateur transmettra par l'intermédiaire du clavier. Type spécifie les caractères qui sont permis d'être saisis. Maxlen peut être utilisé pour limiter la longueur maximale de l'entrée de l'utilisateur (défaut: 0, se qui signifie aucune limite). Si password est réglé sur TRUE, Hollywood affichera des "*" pour chaque caractère saisi. Les types suivants peuvent être spécifiés : #ALL - recevra tous les caractères visibles #ALPHABETICAL - recevra seulement les lettres; ceci n'est pas forcément limité aux caractères de a-z. l'utilisateur peut saisir également les lettres spéciales qui sont disponible dans l'alphabet de sa langue #ALPHANUMERICAL - recevra les caractères alphabétiques et numériques #HEXNUMERICAL - recevra les caractères hexadécimaux (0-9 et a-f) #NUMERICAL - recevra 0-9 Si vous avez les calques activé tout en utilisant cette commande, vous obtiendrez un nouveau calque de type #PRINT qui contiendra la chaîne que l'utilisateur a saisi (dans les versions précédentes de Hollywood 2.0, un calques été ajoutés pour chaque caractère). @{b}INPUTS@{ub} type - spécifie quel type de caractères sera permis à la saisie maxlen - optionnel: si vous spécifiez cet argument, l'utilisateur ne sera en mesure que de saisir maxlen caractères; sinon il peut entrer autant de caractères qu'il veut et terminer sa saisie en appuyant sur la touche RETURN(défauts: 0, se qui signifie que l'utilisateur peut entrer autant de caractères qu'il le veut) password - optionnel: si il est activé avec TRUE, Hollywood affichera des "*" au lieu du caractère réel introduit au clavier (défauts: FALSE) @{b}RESULTATS@{ub} input$ - la chaîne qui a été saisie @{b}EXEMPLE@{ub} Print("Quel est votre nom ?") name$ = InKeyStr(#ALPHABETICAL) Print("Bonjour ", name$, "!") Le code ci-dessus demande à l'utilisateur d'écrire son nom et alors il sera affiché. @ENDNODE @NODE SetEventTimeout "Guide Hollywood" @{b}NOM@{ub} SetEventTimeout() -- définir la durée du temps caché d'un événement (V1.9) @{b}SYNOPSIS@{ub} SetEventTimeout(duration) @{b}FONCTION@{ub} Vous pouvez utiliser Cette commande pour indiquer à Hollywood pendant combien de temps il cachera l'événements d'entrée. La valeur par défaut est 1500 se qui signifie que tous les événements seront cachés 1.5 seconde. Cette commande pourrait être utile si vous avez une commande qui bloque le déroulement du programme pendant un certain temps. Si vous chargez une grande image JPG qui prend environ 5 secondes au chargement, tous les événements qui se produiront pendant ce temps de chargement sont normalement détruits parce que Hollywood rappelle seulement les événements qui se sont produits pendant une durée de 1.5 seconde. Si vous augmentez la durée de cache d'événement en utilisant cette commande, vous pourrez également rappeler les événements qui se sont produits pendant le temps de chargement de l'image. Cependant, Cette commande est seulement utile que dans de rares cas. @{b}INPUTS@{ub} duration - spécifie pendant combien de temps les événements seront cachés (en millisecondes) @{b}EXEMPLE@{ub} SetEventTimeout(5000) Règle la durée du temps caché d'événement à 5 secondes (=5000 millisecondes). @ENDNODE @NODE WaitEvent "Guide Hollywood" @{b}NOM@{ub} WaitEvent -- attendre qu'un événement se produise @{b}SYNOPSIS@{ub} WaitEvent() @{b}FONCTION@{ub} Le commande de WaitEvent() met Hollywood dans la condition de veille. Le programme sera réactivé quand un événement sera déclenché. Dans ce cas, WaitEvent() exécuterà la fonction, celle que vous avez installé pour cet événement, et puis il quittera. Par conséquent, vous devez toujours utiliser WaitEvent() dans une boucle. Par Exemple: While quit = False WaitEvent Wend ou une boucle sans fin : Repeat WaitEvent Forever WaitEvent() est une commande élémentaire du langage Hollywood et vous devez utiliser une des boucles présentées ci-dessus dans chaque script comme boucle principale. WaitEvent() a l'avantage qu'il est en veille jusqu'à ce qu'un événement soit déclenché. C'est important dans un environnement multitche afin de libérer du temps processeur. Ne jamais utiliser les boucles d'interrogation. Elles consomment trop de temps CPU. Si vous devez effectuer continuellement le code dans votre boucle principale, utiliser @{"SetInterval()" LINK SetInterval} pour installer une commande d'intervalle qui ira appelé 25 fois par seconde WaitEvent(). Les fonctions que WaitEvent() peut appeler quand un événement est déclenché peuvent être installé avec les comandes suivantes de la bibliothèque d'événements Hollywood: @{"MakeButton() " LINK MakeButton} @{"SetInterval() " LINK SetInterval} @{"SetTimeout() " LINK SetTimeout} @{"InstallEventHandler() " LINK InstallEventHandler} @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} voir @{"MakeButton() " LINK MakeButton} voir @{"SetInterval() " LINK SetInterval} voir @{"SetTimeout() " LINK SetTimeout} voir @{"InstallEventHandler()" LINK InstallEventHandler} voir les exemples fournient avec Hollywood @ENDNODE @NODE MakeButton "Guide Hollywood" @{b}NOM@{ub} MakeButton() -- créer un nouveau bouton (V2.0) @{b}SYNOPSIS@{ub} [id] = MakeButton(id, type, ...) [id] = MakeButton(id, #SIMPLEBUTTON, x, y, width, height, evttable[, userdata) [id] = MakeButton(id, #LAYERBUTTON, layerid, exactcoll, noautohide, evttable[, userdata]) (V2.5) @{b}FONCTION@{ub} Cette commande créé un nouveau bouton avec des dimensions spécifié et le lie à l'image de fond qui est affiché. Le bouton aura l'identificateur spécifié par l'argument id, ou, si vous indiquez @{"Nil" LINK V6PrgTypeNil} comme id, MakeButton() choisira automatiquement un id vide. L'argument type spécifie le type du bouton. Actuellement les types possibles sont: #SIMPLEBUTTON : créé un bouton simple. Noter que ce bouton est invisible. Vous devez utiliser les graphismes de votre image de fond pour l'afficher à l'utilisateur là où votre bouton est placé. Le type #SIMPLEBUTTON exige que vous indiquiez la position et les dimensions du bouton dans les arguments 3 à 6. Le 7ième argument est un tableau d'événement (voir ci-dessous). #LAYERBUTTON : Depuis Hollywood 2.5, il est possible de créé un bouton dynamique qui sera toujours à la position où le calque se trouve avec l'identité spécifié par layerid. Le bouton utilisera les dimensions du calque spécifié. Le 4ième argument spécifie si votre bouton utilisera une détection de collision au pixel près ou rectangulaire. Si vous indiquez TRUE, les événements seront seulement exécuté avec la détection de collision au pixel près. Ceci vous permet de créer des boutons aux formes irrégulières. Le 5ième argument spécifie si oui ou non le bouton sera caché automatiquement quand le calque est caché. Si vous indiquez TRUE, le bouton ne disparaîtra pas automatiquement quand vous cachez le calque auquelle il est fixé. Si vous indiquez FALSE à noautohide, le bouton disparaîtra dès que vous cacherez le calque. Le sixième argument est un tableau d'événement (voir ci-dessous). Noter que les boutons de calque dépendent du calque auxquels ils sont fixés. Si vous effacer ce calque, le bouton sera également effacé. L'argument evttable est un tableau qui définit les fonctions qui seront appellées si un événement particulier se produit. Se tableau peut contenir les indicateurs suivants : OnMouseOver : Le commande spécifiée ici sera appelé quand l'utilisateur déplacerà la souris au-dessus de la position du bouton. OnMouseOut : Le commande spécifiée ici sera appelé quand le pointeur de la souris quitte la position occupé par ce bouton. OnMouseDown : Le commande spécifiée ici sera appelé quand l'utilisateur actionne le bouton gauche de la souris tandis que le pointeur de souris est sortie de la position du bouton. OnMouseUp : Le commande spécifiée ici sera appelé quand l'utilisateur relchera le bouton gauche de la souris tandis que le pointeur de souris est sortie de la position du bouton. Cet événement sera seulement déclenché si l'utilisateur a également actionné le bouton gauche de la souris tandis que le pointeur de souris était au-dessus de la position du bouton. OnRightMouseDown : Idem que OnMouseDown mais avec le bouton droit de souris. OnRightMouseUp : Idem que OnMouseUp mais avec le bouton droit de la souris. Si vous voulez juste tester si la souris clique sur un bouton, il suffit d'exécuter une commande de rappel de service pour le type d'événement OnMouseUp. OnMouseDown est seulement exigé, si vous voulez mettre en valeur le bouton d'une manière quelconque quand l'utilisateur clic dessus. Depuis Hollywood 3.1 il y a un argument optionnel appelé "userdata". La valeur que vous spécifiez ici est retourné à votre commande de rappel de service à chaque fois que vous l'interrogez. C'est utile si vous voulez éviter de travailler avec des variables globales. L'argument "userdata" peut transmettre facilement des données à votre commande de rappel de service. Vous pouvez spécifier tous types de valeur dans "userdata": Nombres, chaînes, tableaux, et fonctions d'événements peuvent être déclaré comme données utilisateur. Les fonctions de rappel de service que vous spécifiez dans le tableau seront déclarés par Hollywood avec un paramètre. Ce paramètre est un tableau de message qui contient quelques informations sur l'événement. Les indicateurs suivants sont disponible: Action : Contient le nom de l'événement déclenché, par exemple "OnMouseUp","OnMouseOver" ou "OnMouseOut". Cet indicateur est une chaîne. id : Contient l'identificateur du bouton qui a déclenché cet événement. Cet indicateur est un nombre. x, y, Width, Height : ces indicateurs contiennent les dimensions du bouton MouseDown : Cet indicateur retournera TRUE si le bouton gauche de la souris est actionné. Très utiles si un lien existe avec l'événement OnMouseOver, de sorte que vous puissiez afficher avec une version de mise en valeur différentes du bouton si l'utilisateur déplace le pointeur de souris sur le bouton tandis que le bouton gauche de la souris est actionné. RightMouseDown : Mêmes que MouseDown mais avec le bouton droit de la souris. UserData : Contient la valeur que vous avez indiqué dans l'argument userdata quand vous avez créé le bouton. L'avantage de ce message est, que vous pouvez utiliser qu'une et de plus la même commande pour tous vos boutons et tous les événements. Examiner juste les indicateurs Action et id pour découvrir quel bouton génére quel événement. Note: Les boutons sont toujours liés à l'image de fond. Donc, si vous appelez MakeButton() tandis que BGPic 1 est affiché, le bouton sera lié à BGPic 1. Si vous affichez BGPic 2, les boutons ne seront plus affichés. Une fois que vous commutez de nouveau à BGPic 1, les boutons seront de nouveau affiché. Noter également que vous pouvez seulement créer des boutons de forme rectangulaire avec #SIMPLEBUTTON. Si vous voulez créer des boutons de forme irrégulière, créer un calque qui peut avoir un réglage de transparence (masque ou un canal alpha transparent) et utilisé #LAYERBUTTON pour lier un bouton à ce calque. @{b}INPUTS@{ub} id - identificateur pour le nouveau bouton ou @{"Nil" LINK V6PrgTypeNil} pour @{"sélection automatique d'id" LINK AutoIDSelect} type - type du nouveau bouton Pour #SIMPLEBUTTON : x - position en x du nouveau bouton y - position en y du nouveau bouton width - largeur du nouveau bouton height - hauteur du nouveau bouton evttable - tableau qui contient les fonctions de rappel de service qui seront appelées si un événement particulier se produit userdata - optionnel: données utilisateur qui seront retournées à la commande de rappel de service (V3.1) Pour #LAYERBUTTON : layerid - id du calque auquel le nouveau bouton sera lié exactcoll - TRUE ou FALSE; spécifie si oui ou non ce bouton utilise la détection de collision au pixel près (utile pour créer des boutons de forme irrégulière) noautohide - TRUE ou FALSE; régler ceci sur TRUE si le bouton ne doit pas être caché si le calque est caché evttable - tableau qui contient les fonctions de rappel de service qui seront appelées si un événement particulier se produit userdata - optionnel: données utilisateur qui seront retournées à la commande de rappel de service (V3.1) @{b}RESULTATS@{ub} id - optionnel: identificateur du bouton; sera seulement retourné quand vous indiquez @{"Nil" LINK V6PrgTypeNil} comme argument 1 (voir ci-dessus) @{b}EXEMPLE@{ub} Function p_MyFunc(msg) Switch msg.action Case "OnMouseUp": DebugPrint("L'utilisateur a effectué un clic gauche", msg.id) Case "OnMouseOver": DebugPrint("L'utilisateur a déplacé le pointeur de souris au dessus du bouton", msg.id) Case "OnRightMouseUp": DebugPrint("L'utilisateur a effectué un clic droit", msg.id) EndSwitch EndFunction ; tracer les boutons Box(0, 0, 100, 100, #RED) Box(200, 200, 100, 100, #BLUE) ; les installers evtmatch = {OnMouseUp = p_MyFunc, OnMouseOver = p_MyFunc, OnRightMouseUp = p_MyFunc} MakeButton(1, #SIMPLEBUTTON, 0, 0, 100, 100, evtmatch) MakeButton(2, #SIMPLEBUTTON, 200, 200, 100, 100, evtmatch) Repeat WaitEvent Forever @ENDNODE @NODE EnableButton "Guide Hollywood" @{b}NOM@{ub} EnableButton -- activer un bouton (V2.0) @{b}SYNOPSIS@{ub} EnableButton(id) @{b}FONCTION@{ub} Cette commande active le bouton avec le numéro id. C'est seulement nécessaire si vous l'avez désactivé précédemment en utilisant @{"DisableButton()" LINK DisableButton}. @{b}INPUTS@{ub} id - identificateur du bouton à activer @ENDNODE @NODE DisableButton "Guide Hollywood" @{b}NOM@{ub} DisableButton -- désactiver un bouton (V2.0) @{b}SYNOPSIS@{ub} DisableButton(id) @{b}FONCTION@{ub} Cette commande désactive temporairement le bouton avec le numéro id. Vous pouvez l'activer plus tard en utilisant la commande @{"EnableButton()" LINK EnableButton} . Si vous voulez retirer complètement un bouton, utiliser la commande @{"DeleteButton()" LINK DeleteButton}. @{b}INPUTS@{ub} id - identificateur du bouton à désactiver @ENDNODE @NODE DeleteButton "Guide Hollywood" @{b}NOM@{ub} DeleteButton -- effacer un bouton (V2.0) @{b}SYNOPSIS@{ub} DeleteButton(id) @{b}FONCTION@{ub} Cette commande efface le bouton avec l'id spécifié de l'image de fond d'écran. @{b}INPUTS@{ub} id - identificateur du bouton à effacer @ENDNODE @NODE SetInterval "Guide Hollywood" @{b}NOM@{ub} SetInterval -- installer une nouvelle commande d'intervalle (V2.0) @{b}SYNOPSIS@{ub} [id] = SetInterval(id, func, ms[, userdata]) @{b}FONCTION@{ub} Cette commande installe une nouvelle commande d'intervalle et lui affecte l'identificateur id à celle-ci. Si vous indiquez @{"Nil" LINK V6PrgTypeNil} comme id, SetInterval() choisira automatiquement une id vide et la retournera. Vous devez spécifier une commande Hollywood dans l'argument func et le temps en millisecondes qui définit l'intervalle. La commande que vous avez spécifié sera exécuté à plusieurs reprises à intervalles du temps spécifié. Par exemple si vous indiquez 40 comme intervalle, votre commande sera exécutée toutes les 40 ms qui correspond à 25 fois par seconde (25 * 40ms = 1000ms = 1 seconde). C'est assez pour la plupart des jeux, introductions etc. Vous devez toujours utiliser @{"WaitEvent()" LINK WaitEvent} avec cette commande. Si vous installez une commande d'intervalle, le programmateur d'horloge interne Hollywood déclenchera des événements d'intervalle et demandera à WaitEvent() d'appeler votre commande d'intervalle. Les intervalles ne fonctionnent pas sans WaitEvent(). Si vous n'utilisez pas WaitEvent(), votre commande d'intervalle ne sera jamais appeler. Les commandes d'intervalle s'appellent seulement tant que vous êtes dans une boucle WaitEvent(). Cette commande est très importante parce qu'elle vous aide à vous assurer que votre script fonctionne à la même vitesse sur chaque système. Lire la @{"temporisation de script" LINK V6PrgG2KTiming} pour plus d'information sur cette commande et également pour un exemple de SetInterval(). Vous pouvez installer autant d'intervalles que vous le voulez. Le programmateur interne d'Hollywood s'assurera que toutes les fonctions d'intervalles soient appellées correctement. Rappelez-vous que Hollywood ne supporte pas le multithreading. Par conséquent vos fonctions d'intervalle ne doivent pas bloquer le script, autrement tout le script sera bloquée. Par exemple, si vous avez deux fonctions d'intervalle installé et qu'une de ces fonctions exécute une attente Wait(100), le script sera bloquée pendant 2 secondes. Vous pouvez utiliser @{"ClearInterval()" LINK ClearInterval} pour arrêter une commande d'intervalle. Depuis Hollywood 3.1 il y a un argument optionnel appelé "userdata". La valeur que vous spécifiez ici sera retourné dans votre commande de rappel de service chaque fois qu'elle sera appelée. C'est utile si vous voulez éviter de travailler avec des variables globales. l'argument "userdata" vous permet de transmettre facilement des données à votre commande de rappel de service. Vous pouvez spécifier une valeur selon les types suivant: Nombres, chaînes, tableaux, et fonctions peuvent être utilisé comme données utilisateur. Votre commande d'intervalle sera exécutée par Hollywood avec un paramètre. Ce paramètre est un tableau de message qui contient ces indicateurs: Action : Sera toujours réglé sur "Interval". Cet indicateur est une chaîne. id : Sera réglé à l'id de l'intervalle que Hollywood doit exécuter. UserData : Sera réglé en fonction de se que vous avez indiqué dans l'argument userdata quand vous avez installé l'interval de temps. Ce message est utile si vous voulez traiter deux intervalles ou plus dans la même fonction. Le message vous indique quel intervalle Hollywood aura accompli. Si vous n'avez pas besoin de ce message, n'en prenez pas compte. Aller voir les exemples fourni avec Hollywood. Bon nombre d'entre eux utilise SetInterval() pour contrôler le timing du script. @{b}INPUTS@{ub} id - identificateur pour la nouvelle commande d'intervalle ou @{"Nil" LINK V6PrgTypeNil} pour la @{"sélection automatique d'id" LINK AutoIDSelect}; l'identificateur est nécessaire de sorte que vous puissiez arrêter l'intervalle plus tard en utilisant la commande @{"ClearInterval()" LINK ClearInterval} funct - commande Hollywood qui doit être exécuté à l'interval de temps indiqué Ms - intervals auxquels la commande sera exécuté, par exemple, 40 exécutera appellerà la commande 25 fois par seconde parce que: 25 * 40ms = 1000ms = 1 seconde userdata - optionnel: données utilisateur à transmettre dans la commande de rappel de service (V3.1) @{b}RESULTATS@{ub} id - optionnel: identificateur de l'intervalle; sera seulement retourné quand vous indiquez @{"Nil" LINK V6PrgTypeNil} comme argument 1 @{b}EXEMPLE@{ub} voir @{"Temporisation du script" LINK v6PrgG2KTiming} @ENDNODE @NODE ClearInterval "Hollywood Guide" @{b}NOM@{ub} ClearInterval -- retirer une commande d'intervalle (V2.0) @{b}SYNOPSIS@{ub} ClearInterval (id) @{b}FONCTION@{ub} Cette commande interrompt l'appel d'une commande d'intervalle spécifié par @{b}id@{ub}. Voir la documentation de la commande @{"SetInterval()" LINK SetInterval}. @{b}INPUTS@{ub} id - identificateur de la commande d'intervalle à annuler @{b}EXEMPLE@{ub} voir @{"SetInterval" LINK SetInterval} @ENDNODE @NODE ChangeInterval "Hollywood GUIDE" @{b}NOM@{ub} ChangeInterval -- changer la fréquence d'interval (V2.0) @{b}SYNOPSIS@{ub} ChangeInterval(id, ms) @{b}FONCTION@{ub} Cette commande peut être utilisé pour changer la fréquence d'un interval en fonctionnement. Spécifier juste l'id de l'intervalle et sa nouvelle fréquence. Voir la documentation @{"SetInterval()" LINK SetInterval}. @{b}INPUTS@{ub} id - identificateur de la commande d'intervalle à modifier Ms - nouvelle fréquence d'intervalle en millisecondes @ENDNODE @NODE SetTimeout "Hollywood GUIDE" @{b}NOM@{ub} SetTimeout -- installer une nouvelle commande d'interval de temps (V2.0) @{b}SYNOPSIS@{ub} [id] = SetTimeout (id, func, timeout [, userdata]) @{b}FONCTION@{ub} Cette commande installe une nouvelle commande d'interval de temps et lui lui affecte l'identificateur id. Si vous indiquez @{"Nil" LINK V6PrgTypeNil} comme identification. SetTimeout() choisira automatiquement une id vide et la renverra. Vous devez spécifier une commande Hollywood dans l'argument func et le temps en ms. Après que ce temps se soit écoulée, Hollywood appellera votre commande d'interval de temps. C'est utile si vous avez besoin d'un calage précis, par exemple si vous voulez synchroniser des images avec de la musique. les commandes d'interval de temps sont parfaites pour se genre de créations. Vous devez toujours utiliser @{"WaitEvent" LINK WaitEvent} en lien avec cette commande. Si vous installez une commande d'interval de temps, le chronomètre interne d'Hollywood déclenchera des événements d'interval de temps et informera WaitEvent() d'appeler votre commande d'interval de temps. Les intervals de temps ne fonctionnent pas sans WaitEvent(). Si vous n'utilisez pas WaitEvent(), votre commande d'interval de temps ne sera jamais appelé. Les commandes d'intervals de temps seront seulement exécutées tant que vous êtes dans une boucle WaitEvent(). Vous pouvez installer autant d'interval de temps que vous le voulez. le programmateur interne d'Hollywood s'assurera que toutes les commandes d'interval de temps soient appelées correctement. Vous pouvez utiliser @{"ClearTimeout" LINK ClearTimeout} pour arrêter une commande d'intervalle de temps. Depuis Hollywood 3.1 il y a un argument optionnel appelé "userdata". La valeur que vous spécifiez ici sera retourné dans votre commande de rappel de service chaque fois qu'elle sera appelée. C'est utile si vous voulez éviter de travailler avec des variables globales. l'argument "userdata" vous permet de transmettre facilement des données à votre commande de rappel de service. Vous pouvez spécifier une valeur selon les types suivant: Nombres, chaînes, tableaux, et fonctions peuvent être utilisé comme données utilisateur. Votre commande d'intervalle sera exécutée par Hollywood avec un paramètre. Ce paramètre est un tableau de message qui contient ces indicateurs: Votre commande d'intervalle de temps sera appelé par Hollywood avec un paramètre. Ce paramètre est un tableau de message qui contient deux indicateurs: Action : Sera toujours réglé sur "Interval". Cet indicateur est une chaîne. id : Sera réglé à l'id de l'intervalle que Hollywood doit exécuter. UserData : Sera réglé en fonction de se que vous avez indiqué dans l'argument userdata quand vous avez installé l'interval de temps. Ce message est utile si vous voulez traiter deux intervalles ou plus dans la même fonction. Le message vous indique quel intervalle Hollywood aura accompli. Si vous n'avez pas besoin de ce message, n'en prenez pas compte. Aller voir les exemples fourni avec Hollywood. Bon nombre d'entre eux utilise SetInterval() pour contrôler le timing du script. @{b}INPUTS@{ub} id - identificateur pour la nouvelle commande d'intervalle ou @{"Nil" LINK V6PrgTypeNil} pour la @{"sélection automatique d'id" LINK AutoIDSelect}; l'identificateur est nécessaire de sorte que vous puissiez arrêter l'intervalle plus tard en utilisant la commande @{"ClearInterval()" LINK ClearInterval} funct - commande Hollywood qui doit être exécuté à l'interval de temps indiqué Ms - intervals auxquels la commande sera exécuté, par exemple, 40 exécutera appellerà la commande 25 fois par seconde parce que: 25 * 40ms = 1000ms = 1 seconde userdata - optionnel: données utilisateur à transmettre dans la commande de rappel de service (V3.1) @{b}RESULTATS@{ub} id - optionnel: identificateur de l'intervalle; sera seulement retourné quand vous indiquez @{"Nil" LINK V6PrgTypeNil} comme argument 1 @{b}EXEMPLE@{ub} Function p_TenSeconds() SystemRequest ("Hollywood", " Dix secondes se sont écoulé maintenant! ", "OK") EndFunction SystemRequest ("Hollywood", "je vais appelé la commande TenSeconds() après que 10 secondes se soit écoulé !\ \ n ". " Vérifier votre montre, et cliquer sur GO ! ", " Allons-y!") SetTimeout(1, p_TenSeconds, 10000) Repeat WaitEvent Forever Le code ci-dessus monte une commande d'intervalle de temps qui sera exécuté après que 10000 millisecondes (= 10 secondes) se soit écoulé. @ENDNODE @NODE ClearTimeout "Hollywood Guide" @{b}NOM@{ub} ClearTimeout -- annuler une commande d'interval de temps (V2.0) @{b}SYNOPSIS@{ub} ClearTimeout(id) @{b}FONCTION@{ub} Cette commande arrête l'interval de temps spécifié par id. Voir la documentation de la commande @{"SetTimeout" LINK SetTimeout}. Il n'est pas nécessaire d'arrêter les commandes d'interval de temps qui sont exécutées. Hollywood les libérera automatiquement. @{b}INPUTS@{ub} id - identificateur de la commande d'interval de temps à annuler @{b}EXEMPLE@{ub} voir @{"SetTimeout()" LINK SetTimeout} @ENDNODE @NODE InstallEventHandler "Hollywood Guide" @{b}NOM@{ub} InstallEventHandler() -- installer/désinstaller le gestionnaire d'événements (V2.0) @{b}SYNOPSIS@{ub} InstallEventHandler (table [, userdata]) @{b}FONCTION@{ub} Vous pouvez utiliser cette commande pour installer vos propres gestionnaires d'événement pour des événements standard. Vous devez lié un tableau à cette commande, il indique à Hollywood quels gestionnaires d'événement vous voulez installer ou désinstaller. Pour installer un nouveau gestionnaire d'événements, vous devez initialiser le tableau correspondant avec vos propres fonction. Si vous voulez désinstaller un gestionnaire d'événement, régler le tableau correspondant à 0. Les indicateurs du tableau suivants sont reconnus par cette commande: OnKeyDown : Cette commande sera appelée chaque fois que l'utilisateur appuie sur une touche. La commande recevra un message comme paramètre 1 avec les indicateurs suivant: Action : Initialisé à "OnKeyDown". Key : Sera réglé sur la touche qui a été actionnée. OnKeyUp : La commande que vous spécifiez ici sera appelé chaque fois que l'utilisateur relche une touche. La commande recevra un message comme paramètre 1 avec les indicateurs suivant: Action : Initialisé à "OnKeyUp". Key : Sera réglé sur la touche qui a été relchée. OnMouseMove : Cette commande sera appelée chaque fois que l'utilisateur déplace la souris. La commande recevra un message comme paramètre 1 avec les indicateurs suivant: Action : Initialisé à "OnMouseMove". x, y : Sera réglé à la position du pointeur de souris actuel. Ils seront négatifs, si le pointeur de souris est en dehors de l'écran. OnMouseDown : Cette commande sera appelée chaque fois que l'utilisateur (V3.1) actionne le bouton gauche de la souris. La commande recevra un message comme paramètre 1 avec l'indicateur suivant: Action : Initialisé à "OnMouseDown". OnMouseUp : Cette commande sera appelée chaque fois que l'utilisateur (V3.1) relche le bouton gauche de la souris. La commande recevra un message comme paramètre 1 avec l'indicateur suivant: Action : Initialisé à "OnMouseUp". OnRightMouseDown : Cette commande sera appelée chaque fois que l'utilisateur (V3.1) actionne le bouton droit de la souris. La commande recevra un message comme paramètre 1 avec l'indicateur suivant: Action : Initialisé à "OnRightMouseDown". OnRightMouseUp : Cette commande sera appelée chaque fois que l'utilisateur (V3.1) relche le bouton droit de la souris. La commande recevra un message comme paramètre 1 avec l'indicateur suivant: Action : Initialisé à "OnRightMouseUp". OnWheelDown : Cette commande sera appelée chaque fois que l'utilisateur (V4.0) déplace la roue de la souris vers le bas. La commande recevra un message comme paramètre 1 avec l'indicateur suivant: Action : Initialisé à "OnWheelDown". OnWheelUp : Cette commande sera appelée chaque fois que l'utilisateur (V4.0) déplace la roue de la souris vers le haut. La commande recevra un message comme paramètre 1 avec l'indicateur suivant: Action : Initialisé à "OnWheelUp". OnMusicEnd : Cette commande sera appelée chaque fois qu'une musique est terminé d'être joué. La commande recevra un message comme paramètre 1 avec les indicateurs suivant: Action : Initialisé à "OnMusicEnd". id : Identificateur de la musique qui s'est arrêtée. Noter que cet événement est seulement déclenché quand la musique est terminé de joué. Elle n'est pas déclenchée quand vous utilisez @{"StopMusic()" LINK StopMusic}. OnSampleLoop : Cette commande sera appelée chaque fois qu'un échantillon aura démarré. Si l'échantillon est seulement joué une fois, la commande sera seulement appelé une fois. Si l'échantillon joue en mode boucle, le commande que vous spécifiez sera appelé à chaque fois que Hollywood répètera l'échantillon. la commande recevra un message comme paramètre 1 avec les indicateurs suivant: Action : Initialisé à "OnSampleLoop". id : Identificateur de l'échantillon qui a été démarré ou répété. Time : Le temps en millisecondes que l'échantillon sera joué. Starts : Le nombre de fois où cet échantillon a été démarré. Cet indicateur commence à 1 et sera augmenté à chaque fois que Hollywood bouclera votre échantillon. @{APEN 4}@{b}ATTENTION:@{ub}@{APEN 1} utiliser ce gestionnaire d'événement avec soin. Si vous avez un échantillon court qui est bouclé indéfiniment, votre commande de rappel de service sera appelé à plusieurs reprises, se qui pourrait altéré le rendement de votre script. Ce gestionnaire d'événement vous permet de réaliser un calage précis avec la lecture de l'échantillon. OnSampleEnd : Cette commande sera appelée chaque fois qu'un échantillon est terminé de joué. La commande recevra un message comme paramètre 1 avec les indicateurs suivant: Action : Initialisé à "OnSampleEnd". id : Identificateur de l'échantillon qui s'est arrêté. Time : Le temps en millisecondes que l'échantillon sera joué. Starts : Le nombre de fois où cet échantillon sera démarré. Cet indicateur commence à 1 et sera augmenté chaque à fois que Hollywood bouclera votre échantillon. Noter que cet événement est seulement déclenché lorsque l'échantillon est terminé de joué. Il n'est pas déclenché quand vous appelez @{"StopSample()" LINK StopSample}. OnARexx : Cette commande sera appelée chaque fois qu'un nouveau (V2.5) message ARexx est réceptionné au port Rexx créé avec @{"CreateRexxPort()" LINK CreateRexxPort}. La commande recevra un message comme paramètre 1 avec les indicateurs suivant: Action : Initialisé à "OnARexx". Command : Une chaîne avec la commande qui sera exécuté. Args : Une chaîne pré analysée qui contient tout les arguments pour cette commande délimitée par le caractère null ("\\ 0"). Vous pouvez utiliser la la commande @{"SplitStr()" LINK SplitStr} pour extraire les différents arguments. ArgC : Le nombre d'arguments dans la chaîne "Args". RawArgs : La chaîne contenant tous les arguments. Noter que Hollywood ne pourra pas toujours séparer les arguments de la manière dont vous voulez les avoir. Dans ce cas, vous pouvez utiliser l'indicateur "RawArgs" pour accéder aux arguments dans leur format original comme Hollywood les a reçu. Les indicateurs "Args" et "ArgC" sont inclus juste pour des raisons de commodité mais quelques utilisateurs avancés pourrait préférer parfois utiliser "RawArgs". Voir la documentation de @{"CreateRexxPort()" LINK CreateRexxPort} pour un exemple de ce gestionnaire d'événement. SizeWindow : Cette commande sera appelée chaque fois que l'utilisateur redimensionne la fenêtre. La commande recevra un message comme paramètre 1 avec les indicateurs suivant: Action : Initialisé à "SizeWindow". Width : Nouvelle largeur de la fenêtre Height : Nouvelle hauteur de la fenêtre MoveWindow : Cette commande sera appelée chaque fois que l'utilisateur déplace la fenêtre. La commande recevra un message comme paramètre 1 avec les indicateurs suivants: Action : Initialisé à " MoveWindow ". x, y : Nouvelle position de la fenêtre sur l'écran. CloseWindow : Cette commande sera appelée chaque fois que l'utilisateur fermerà la fenêtre. Vous pouvez l'utiliser afin d'effectuer un saut vers une requête qui demande à l'utilisateur si il veut quitter. Indicateur de message: Action : Initialisé à "CloseWindow". ActiveWindow : Cette commande sera appelée à chaque fois que la fenêtre Hollywood deviendra active. Indicateurs de message: Action : Initialisé à "ActiveWindow". InactiveWindow : Cette commande sera appelée à chaque fois que la fenêtre Hollywood deviendra inactive. Indicateur de message: Action : Initialisé à "InactiveWindow". ShowWindow : Cette commande sera appelé chaque fois que l'utilisateur (V3.0) affiche la fenêtre caché Hollywood de nouveau sur écran. Indicateur de message : Action : Initialisé à "ShowWindow". HideWindow : Cette commande sera appelée à chaque fois que la fenêtre Hollywood (V3.0) sera caché par l'utilisateur. Indicateur de message : Action : Initialisé à "HideWindow". Si vous voulez retirer un gestionnaire d'événement, régler simplement l'indicateur correspondant dans le tableau à 0. Depuis Hollywood 3.1 il y a un argument optionnel appelé "userdata". La valeur que vous spécifiez ici est transmise à votre commande de rappel de service chaque fois qu'elle est exécutée. C'est utile si vous voulez éviter d'utiliser des variables globales. En utilisant l'argument "userdata" vous pouvez transmettre facilement des données à votre commande de rappel de service. Vous pouvez spécifier n'importe qu'elle type de valeur dans "userdata". Nombres, chaînes, tableaux, et fonctions peuvent être transmises comme données utilisateur. Noter que les commandes de gestionnaire d'événement sont seulement accomplis si dans le script vous utilisez une boucle @{"WaitEvent()" LINK WaitEvent}. Vous devez utiliser WaitEvent(). @{b}INPUTS@{ub} table - tableau qui contient des informations sur les événements à installer ou désinstaller userdata - optionnel: données utilisateur qui seront transmisent au commande de rappel de service (V3.1) @{b}EXEMPLE@{ub} Function p_HandlerFunc(msg) Switch(msg.action) Case "ActiveWindow": DebugPrint("La fenêtre est de nouveau active!") Case "InactiveWindow": DebugPrint("La fenêtre est inactive!") Case "MoveWindow": DebugPrint("L'utilisateur à déplacé la fenêtre a", msg.x, msg.y) Case "OnKeyDown": If msg.key = "ESC" Then End EndSwitch EndFunction InstallEventHandler({ActiveWindow = p_HandlerFunc, InactiveWindow = p_HandlerFunc, MoveWindow = p_HandlerFunc, OnKeyDown = p_HandlerFunc}) Repeat WaitEvent Forever Le code ci-dessus installe quatre gestionnaires d'événement pour: ActiveWindow, InactiveWindow, MoveWindow et OnKeyDown. Si l'utilisateur appuie sur la touche ESC, le programme sera quitté. Si vous voulez retirer par exemple le gestionnaire d'événement MoveWindow: appelé juste InstallEventHandler() de nouveau avec le paramètre: {MoveWindow = 0}. @ENDNODE @NODE CtrlCQuit "Hollywood Guide" @{b}NOM@{ub} CtrlCQuit -- activer/désactiver le Control-C (V2.0) @{b}SYNOPSIS@{ub} CtrlCQuit(enable) @{b}FONCTION@{ub} Par défaut, tous les scripts Hollywood peuvent être interrompues à tout moment juste en actionnant Control-C. Si vous voulez le désactiver, utiliser cette commande avec l'indication FALSE. Note: Penser à deux fois avant de désactiver Control-C. Par exemple, si votre script s'exécute dans une fenêtre sans bord ou en plein écran, il n'y aura aucun gadget de fermeture, la seule façon de quitter resterait la méthode Control-C. @{b}INPUTS@{ub} enable - TRUE pour activé CTRL-c, FALSE pour le désactiver @ENDNODE @NODE LeftMouseQuit "Hollywood Guide" @{b}NOM@{ub} LeftMouseQuit -- activer/désactiver la fermeture du programme avec le bouton gauche de la souris @{b}SYNOPSIS@{ub} LeftMouseQuit(enable) @{b}FONCTION@{ub} Si vous indiquez TRUE dans enable, l'utilisateur pourra arrêter à tous moment votre Script avec le bouton gauche de la souris. C'est utile lorsque vous créez des présentations ou diaporama mais pas pour des applications avec une interaction utilisateur. Si vous créez un certain type de démonstration avec Hollywood, il est judicieux d'utiliser cette commande afin de permettre à l'utilisateur de quitter à tous moments. Si vous indiquez FALSE dans enable, cette caractéristique sera désactiver. @{b}INPUTS@{ub} Enable - TRUE active la fermeture du programme avec le bouton gauche de la souris, FALSE pour désactiver @{b}EXEMPLE@{ub} LeftMouseQuit(TRUE) Repeat Wait(10) Forever Le code ci-dessus créé une boucle sans fin qui bloque votre programme. Mais l'utilisation de LeftMouseQuit(TRUE) permet à l'utilisateur de quitter quand il le désire. @ENDNODE @NODE EscapeQuit "Hollywood Guide" @{b}NOM@{ub} EscapeQuit -- activer/désactiver la fermeture du programme avec la touche ESC (V1.5) @{b}SYNOPSIS@{ub} EscapeQuit(enable) @{b}FONCTION@{ub} Si vous indiquez TRUE dans enable, l'utilisateur pourra arrêter à tous moment votre Script avec la touche ESC. C'est utile lorsque vous créez des présentations ou diaporama mais pas pour des applications avec une interaction utilisateur. Si vous créez un certain type de démonstration avec Hollywood, il est judicieux d'utiliser cette commande afin de permettre à l'utilisateur de quitter à tous moments. Si vous indiquez FALSE dans enable, cette caractéristique sera désactiver. @{b}INPUTS@{ub} enable - TRUE active la fermeture du programme avec la touche ESC, FALSE pour désactiver @{b}EXEMPLE@{ub} EscapeQuit(TRUE) Repeat Wait(10) Forever code ci-dessus créé une boucle sans fin qui bloque votre programme. Mais l'utilisation de EscapeQuit(TRUE) permet à l'utilisateur de quitter quand il le désire. @ENDNODE @NODE CreateRexxPort "Hollywood Guide" @{b}NOM@{ub} CreateRexxPort() -- créer un port Rexx pour votre script (V2.5) @{b}SYNOPSIS@{ub} CreateRexxPort(name$) @{b}FONCTION@{ub} Cette commande créée un port rexx pour votre script et lui affectera un nom spécifié par name$. Afin de recevoir les messages ARexx, votre script doit avoir un port ARexx. D'autres applications peuvent alors communiquer avec votre script en envoyant des messages à ce port. Tous les messages qui seront envoyés sur votre port Rexx seront transmis par l'intermédiaire de la commande de rappel de service que vous devrez installer en utilisant la commande @{"InstallEventHandler()" LINK InstallEventHandler} (utiliser le gestionnaire d'événement OnARexx). Si vous n'installez pas ce gestionnaire d'événement, vous ne pourrez pas obtenir tous les messages entrants. Rappelez-vous que les noms de port Rexx respectent le format minuscule et majuscule. Donc, "MYPORT" et "myport" indiquent deux ports Rexx différents. Pour des raisons de style, il est préférable d'utiliser que les caractères majuscules pour écrire le nom. De plus, chaque port Rexx doit être unique dans votre système. Si vous spécifiez un nom qui est déjà utilisé, cette commande retournera un message d'erreur. Assurez-vous que vous utilisez un nom non utilisé. Noter que chaque script Hollywood peut seulement avoir qu'un seul port ARexx. Par conséquent, cette commande peut être appelé qu'une seule fois dans votre script. Vous ne pouvez pas effacer le port créé avec cette commande. Il sera automatiquement effacer quand Hollywood sera quitté. Voir l'exemple ci-dessus pour comprendre la méthode de récupération des messages ARexx. Voir également la documentation de @{"InstallEventHandler()" LINK InstallEventHandler}. @{b}INPUTS@{ub} name$ - nom désiré pour votre port Rexx @{b}EXEMPLE@{ub} Function p_EventFunc(msg) Switch msg.action Case "OnARexx" Switch msg.command Case "RealFunc" Return(100) Default Local t = SplitStr(msg.args, "\0") DebugPrint(msg.command, "called with", msg.argc, "argument(s)") For Local k = 1 To msg.argc Do DebugPrint("Argument", k .. ":", t[k - 1]) EndSwitch EndSwitch EndFunction CreateRexxPort("MY_COOL_REXX_PORT_123") InstallEventHandler({OnARexx = p_EventFunc}) Repeat WaitEvent Forever ---- Sauvegarder Le code ci-dessus comme script Hollywood et exécuter le avec Hollywood. Ensuite sauvegardé le code suivant comme un script Rexx et l'exécuter du shell avec "RX test.rx": /* rappel: la première ligne de chaque script Rexx doit être un commentaire * OPTIONS RESULTS /* le port de notre script Hollywood est maintenant le serveur * ADDRESS MY_COOL_REXX_PORT_123 /* envoie quelques commandes Rexx à Hollywood et observer le débogage sortir * DummyFunc_1 '"Dummy Arg 1"' DummyFunc_2 1 2 3 DummyFunc_3 '"First arg"' '"Second arg"' '"Third arg"' DummyFunc_4 /* no args */ DummyFunc_5 "These will be handled as separate arguments" DummyFunc_6 '"This is a single argument (use double quotes!)"' 'RealFunc' SAY RESULT /* ceci affichera 100; c'est le résultat de RealFunc */ @ENDNODE @NODE RunRexxScript "Hollywood Guide" @{b}NOM@{ub} RunRexxScript() -- exécuter un script ARexx d'un fichier ou de la mémoire (V2.5) @{b}SYNOPSIS@{ub} res$ = RunRexxScript(script$[, nofile]) @{b}FONCTION@{ub} Vous pouvez utiliser cette commande pour exécuter un script ARexx spécifié dans script$. De plus, vous pouvez également exécuter un script ARexx en réglant l'argument optionnel nofile avec TRUE. Dans ce cas, script$ n'est pas un chemin pour un script ARexx mais doit contenir le code ARexx à exécuter. La commande renverra le résultat du script ARexx. La valeur retourné sera toujours une chaîne, même si elle contient juste un nombre. Si ARexx ne retourne rien, vous recevrez une chaîne vide. Vous devez démarrer RexxMast avant d'utiliser cette commande. Il n'est pas nécessaire de créer un port Rexx pour utiliser cette commande. Cette commande fonctionne également si votre script n'a pas un port Rexx. Le script sera toujours commencé par "REXX" qui est le port de serveur. Donc, si vous voulez adresser un autre port, vous devez utiliser la commande ARexx "ADRESSE" en premier. Si vous utilisez cette commande pour démarrer des scripts externes ARexx, il ne faut pas oublier d'insérer un commentaire dès la première ligne de votre script ARexx. Sinon vous recevrez une erreur "program not found". Comme c'est une question de syntaxe, la première ligne de tous les script ARexx doivent être un commentaire. @{b}INPUTS@{ub} script$ - chemin vers un script ARexx ou directement à un code ARexx; dans le dernier cas, nofile doit être à TRUE nofile - optionnel: FALSE si script$ contient un chemin à un fichier ARexx et TRUE si script$ est directement un code ARexx (par défaut à FALSE) @{b}RESULTATS@{ub} res$ - valeur de renvoi ARexx; c'est toujours une chaîne @{b}EXEMPLE@{ub} RunRexxScript("dh0:MyScript.rx ") Le code ci-dessus exécute le script "dh0:MyScript.rx ". --- r$ = RunRexxScript ("SAY 'bonjour'\\nRETURN 5\\n", True) Le code ci-dessus affiche "bonjour" sur la console et retourne 5 à Hollywood. La variable r$ contiendra ainsi "5" après l'appel. @ENDNODE @NODE SendRexxCommand "Hollywood Guide" @{b}NOM@{ub} SendRexxCommand() -- envoyer une commande au port Rexx (V2.5) @{b}SYNOPSIS@{ub} res$ = SendRexxCommand(port$, cmd$) @{b}FONCTION@{ub} Cette commande transmet une commande spécifié dans cmd$ au port Rexx spécifié dans port$. La commande renverra alors le résultat de la commande. La valeur de renvoi sera toujours une chaîne, même si elle contient juste un nombre. Si la commande ne renvoie rien, vous recevrez une chaîne vide. Vous pouvez également envoyer plusieurs commandes avec cette commande. Séparer juste les commandes avec ";" ou le caractère nouvelle ligne ("\\n"). Si vous ne voulez pas adresser un port particulier Rexx, utiliser simplement "REXX" dans port$. Dans ce cas, le port Rexx par défaut du système sera votre port de serveur. Rappelez-vous que les noms de port Rexx respectent le format minuscule/majuscule, c.-à-d. que "MYPORT" et "myport" indiquent deux ports Rexx différents. Pour des raisons de lisibilité les ports Rexx sont toujours écrit en majuscule. Vous devez démarrer RexxMast avant d'utiliser cette commande. Il n'est pas nécessaire pour créer un port Rexx d'utiliser cette commande. Cette commande fonctionne également si votre script n'a pas un port Rexx. @{b}INPUTS@{ub} port$ - nom du port que vous voulez adresser cmd$ - les commandes que vous voulez transmettre à ce port @{b}RESULTATS@{ub} res$ - valeur de renvoi ARexx; c'est toujours une chaîne @{b}EXEMPLE@{ub} SendRexxCommand ("WORKBENCH", "WINDOW 'Sys:' OPEN") Le code ci-dessus ouvrira le répertoire Sys: sur votre WorkBench. Noter que l'interface ARexx du WorkBench est une option disponible depuis OS3.5. Donc, vous aurez besoin d'OS3.5 minimum. MorphOS ne supporte probablement pas l'interface ARexx du WorkBench puisqu'elle est rarement utilisée. Voir le SDK OS3.9 pour la documentation sur les commandes disponibles. @ENDNODE @NODE V6LibEventARexx "Guide Hollywood" @{b}Fonction ARexx@{ub} @{"CreateRexxPort() " LINK CreateRexxPort } créer un port Rexx pour votre script (V2.5) @{"RunRexxScript() " LINK RunRexxScript } exécuter un script ARexx d'un fichier ou de la mémoire (V2.5) @{"SendRexxCommand() " LINK SendRexxCommand} envoyer une commande au port Rexx (V2.5) @ENDNODE @NODE V6LibEventButton "Guide Hollywood" @{b}Fonction bouton@{ub} @{"DeleteButton() " LINK DeleteButton } effacer un bouton (V2.0) @{"DisableButton() " LINK DisableButton} désactiver un bouton (V2.0) @{"EnableButton() " LINK EnableButton } activer un bouton (V2.0) @{"MakeButton() " LINK MakeButton } créer un nouveau bouton (V2.0) @ENDNODE @NODE V6LibEventHandler "Guide Hollywood" @{b}Fonction installation d'événements@{ub} @{"InstallEventHandler() " LINK InstallEventHandler} installer/désinstaller le gestionnaire d'événement (V2.0) @{"SetEventTimeout() " LINK SetEventTimeout } définir la durée du temps caché d'un événement (V1.9) @{"WaitEvent() " LINK WaitEvent} attendre qu'un événement se produise @ENDNODE @NODE V6LibEventInterval "Guide Hollywood" @{b}Fonction d'intervalle de temps@{ub} @{"ChangeInterval() " LINK ChangeInterval} changer la fréquence d'intervalle (V2.0) @{"ClearInterval() " LINK ClearInterval } retirer une commande d'intervalle (V2.0) @{"SetInterval() " LINK SetInterval } installer une nouvelle commande d'intervalle (V2.0) @ENDNODE @NODE V6LibEventTimeout "Guide Hollywood" @{b}Fonction minuterie@{ub} @{"ClearTimeout() " LINK ClearTimeout} annuler une commande d'intervalle de temps (V2.0) @{"SetTimeout() " LINK SetTimeout } installer une nouvelle commande de intervalle de temps (V2.0) @ENDNODE @NODE V6LibEventInput "Guide Hollywood" @{b}Fonction Entrée utilisateur@{ub} @{"CtrlCQuit() " LINK CtrlCQuit } activer/désactiver le Control-C (V2.0) @{"EscapeQuit() " LINK EscapeQuit } activer/désactiver la fermeture du programme par la touche ESC (V1.5) @{"InKeyStr() " LINK InKeyStr } lire l'entrée du clavier de l'utilisateur (V1.5) @{"IsKeyDown() " LINK IsKeyDown } vérifier si une touche est actionnée (V1.5) @{"IsLeftMouse() " LINK IsLeftMouse } vérifier si le bouton de la souris gauche est actionné @{"IsRightMouse() " LINK IsRightMouse } vérifier si le bouton droit de la souris est actionné (V1.5) @{"LeftMouseQuit() " LINK LeftMouseQuit } activer/désactiver la fermeture du programme par le bouton gauche de la souris @{"JoyDir() " LINK JoyDir } connaître la direction de la manette de jeux (V1.5) @{"JoyFire() " LINK JoyFire } vérifier si le bouton Feu de la manette de jeux est actionné (V1.5) @{"MouseX() " LINK MouseX } connaître la position x de la souris (V1.5) @{"MouseY() " LINK MouseY } connaître la position y de la souris (V1.5) @{"WaitKeyDown() " LINK WaitKeyDown } attendre que l'utilisateur appui sur une touche (V1.5) @{"WaitLeftMouse() " LINK WaitLeftMouse } attendre que l'utilisateur actionne le bouton gauche de la souris @{"WaitRightMouse() " LINK WaitRightMouse} attendre que l'utilisateur actionne le bouton droit de la souris (V1.5) @ENDNODE @NODE V6LibEvent "Guide Hollywood" @{b}Bibliothèque d'événement@{ub} Noter que la bibliothèque d'événement a subi des modifications importantes depuis Hollywood 2.0. La plupart des événements et des commandes Hollywood 1.x sont émulés par Hollywood 2.0. Lire le chapitre @{"Evénements sous Hollywood 1.x" LINK V6LibEventCompat}. @{"Fonctions bouton " LINK V6LibEventButton } Créer des boutons et gérer leurs événements @{"Fonctions installation d'événements " LINK V6LibEventHandler } Documentation de Waitevent() et bien plus @{"Fonctions d'intervalle de temps " LINK V6LibEventInterval} Comment installer une commande d'intervalle de temps @{"Fonction minuterie " LINK V6LibEventTimeout } Comment installer une minuterie @{"Fonctions Entrée utilisateur " LINK V6LibEventInput } Gestion des données utilisateur @{"Evénements sous Hollywood 1.x " LINK V6LibEventCompat } commande compatible avec Hollywood 1.x @ENDNODE @NODE Val "Guide Hollywood" @{b}NOM@{ub} Val -- convertir une chaîne en nombre @{b}SYNOPSIS@{ub} var, chrs = Val(string$) @{b}FONCTION@{ub} Convertit un nombre indiqué dans string$ en variables numérique dans var. Si il n'y a aucun nombre dans la chaîne "string$", 0 est enregistré dans var. La chaîne "string$" peut contenir également des nombres hexadécimaux préfixé avec "$". Nouveau dans Hollywood V2.0 : - vous pouvez obtenir une chaîne qui contient un nombre binaire. Le préfixer simplement avec le signe pourcentage "%". - une deuxième valeur est retournée qui spécifie combien de caractères Val() peut lire dans la chaîne. Ceci vous permet de déterminer la longueur en caractère du nombre. @{b}INPUTS@{ub} string$ - chaîne à convertir en nombre @{b}RESULTATS@{ub} var - variable qui reçoit le nombre converti chrs - nombre de caractère convertis @{b}EXEMPLE@{ub} result, chrs = Val("500 tête de veaux c'est difficile à manger.") Print(result, "-", chrs) Ceci affichera "500-3" à l'écran. @ENDNODE @NODE UpperStr "Guide Hollywood" @{b}NOM@{ub} UpperStr -- convertir une chaîne en lettre majuscule @{b}SYNOPSIS@{ub} var$=UpperStr(string$) @{b}FONCTION@{ub} Convertit tous les caractères dans la chaîne string$ en majuscule. @{b}INPUTS@{ub} string$ - chaîne à convertir en majuscule @{b}RESULTATS@{ub} var$ - chaîne convertie @{b}EXEMPLE@{ub} Print(UpperStr("Hello World!")) Affiche "HELLO WORLD!" à l'écran. @ENDNODE @NODE UnrightStr "Guide Hollywood" @{b}NOM@{ub} UnrightStr -- retirer n caractère(s) de l'extrême gauche d'une chaîne @{b}SYNOPSIS@{ub} var$=UnrightStr(string$,len) @{b}FONCTION@{ub} Retire len caractères de l'extrême gauche de la chaîne string$ et renvois la nouvelle chaîne dans var$. @{b}INPUTS@{ub} string$ - chaîne à modifier len - le nombre de caractère à retirer @{b}RESULTATS@{ub} var$ - chaîne modifié @{b}EXEMPLE@{ub} test$="Hello World!" test$=UnrightStr(test$,6) Print(test$) Ceci affichera "World!". @ENDNODE @NODE UnleftStr "Guide Hollywood" @{b}NOM@{ub} UnleftStr -- retirer n caractère(s) de l'extrême droite d'une chaîne @{b}SYNOPSIS@{ub} var$=UnleftStr(string$,len) @{b}FONCTION@{ub} Retire len caractères de l'extrême droite de la chaîne string$ et renvois la nouvelle chaîne dans var$. @{b}INPUTS@{ub} string$ - chaîne à modifier len - le nombre de caractère à retirer @{b}RESULTATS@{ub} var$ - chaîne modifié @{b}EXEMPLE@{ub} test$="Hello World!" test$=UnleftStr (test$, 7) test$=UnleftStr(test$,7) Ceci affichera "Hello". @ENDNODE @NODE StrStr "Guide Hollywood" @{b}NOM@{ub} StrStr -- convertir un nombre en chaîne @{b}SYNOPSIS@{ub} var$ = StrStr(value[, digits]) @{b}FONCTION@{ub} Convertit la valeur d'un nombre en chaîne et renvoie cette chaîne dans var$. L'argument optionnel digits vous permet de définir combien de positions décimales seront utilisées si la valeur est un nombre à virgule flottante. Il est à 2 par défaut. @{b}INPUTS@{ub} value - nombre à convertir en chaîne digits - optionnel: combien de positions décimales à utiliser si un nombre à virgule flottante est spécifié (2 par défauts) @{b}RESULTATS@{ub} var$ - chaîne contenant la valeur du nombre @{b}EXEMPLE@{ub} test$=StrStr(256) Print(test$) Affiche "256" à l'écran. @ENDNODE @NODE RightStr "Guide Hollywood" @{b}NOM@{ub} RightStr -- retourner les caractères de droite d'une chaîne vers une nouvelle chaîne @{b}SYNOPSIS@{ub} var$=RightStr(string$,len) @{b}FONCTION@{ub} Retourne len caractères à partir de la droite dans la chaîne string$ dans la chaîne var$. @{b}INPUTS@{ub} string$ - chaîne dont il faut extraire les caractères len - le nombre de caractères à dupliquer @{b}RESULTATS@{ub} var$ - chaîne qui reçoit les caractères extraits @{b}EXEMPLE@{ub} test$=RightStr("Hello World!",6) Print(test$) Affiche "World!" à l'écran. @ENDNODE @NODE ReplaceStr "Guide Hollywood" @{b}NOM@{ub} ReplaceStr -- remplacer une chaîne par une autre chaîne @{b}SYNOPSIS@{ub} var$=ReplaceStr(string$,searchstring$,replacestring$[,casesensitive]) @{b}FONCTION@{ub} Recherches la chaîne searchstring$ dans la chaîne string$ et change toutes les séquences identique de la chaîne searchstring$ avec la chaîne replacestring$. L'argument optionnel casesensitive (distinguo majuscules/minuscules) peut être activé (TRUE) ou désactivé (FALSE). Activé (TRUE) par défaut. La nouvelle chaîne est enregistrer dans var$. @{b}INPUTS@{ub} string$ - chaîne dans laquelle il faut chercher la séquence searchstring$ searchstring$ - chaîne à rechercher replacestring$ - chaîne remplacer avec searchstring$ casesensitive - VRAI pour l'activation (défaut), False pour la désactivation @{b}RESULTATS@{ub} var$ - reçoit la nouvelle chaîne @{b}EXEMPLE@{ub} test$="Hello World!" test$=ReplaceStr(test$,"World","People") Print(test$) Ceci affichera "Hello people!" à l'écran. @ENDNODE @NODE MidStr "Guide Hollywood" @{b}NOM@{ub} MidStr -- extraire des caractères d'une chaîne @{b}SYNOPSIS@{ub} var$=MidStr(string$,startpos,len) @{b}FONCTION@{ub} Copie len caractères de la chaîne string$ (commençant à la position startpos) dans la variable chaîne var$. @{b}INPUTS@{ub} string$ - chaîne source startpos - où la copie commencera (premiers caractère = position 0) len - combien de caractères (octets) sera copié @{b}RESULTATS@{ub} var$ - chaîne qui reçoit les caractères extraits @{b}EXEMPLE@{ub} test$=MidStr("Hello World!",4,3) Print(test$) Ceci affichera "o W" à l'écran. @ENDNODE @NODE LowerStr "Guide Hollywood" @{b}NOM@{ub} LowerStr -- convertir tous les caractères dans une chaîne en lettre minuscule @{b}SYNOPSIS@{ub} var$=LowerStr(string$) @{b}FONCTION@{ub} Convertit tous les caractères dans la chaîne string$ en lettre minuscule et enregistre la nouvelle chaîne dans var$. @{b}INPUTS@{ub} string$ - chaîne à convertir @{b}RESULTATS@{ub} var$ - chaîne convertie @{b}EXEMPLE@{ub} test$="Hello World!" test$=LowerStr(test$) Print(test$) Ceci affichera "hello world!" à l'écran. @ENDNODE @NODE LeftStr "Guide Hollywood" @{b}NOM@{ub} LeftStr -- copie n caractères de l'extrême gauche d'une chaîne dans une nouvelle chaîne @{b}SYNOPSIS@{ub} var$=LeftStr(string$,len) @{b}FONCTION@{ub} Copie len caractères de la chaîne string$ à partir de la gauche dans la variable var$ @{b}INPUTS@{ub} string$ - chaîne source len - nombre à copier @{b}RESULTATS@{ub} var$ - chaînes qui reçoit les caractères copier @{b}EXEMPLE@{ub} test$=LeftStr("Hello World!",5) Print(test$) Ceci affichera "Hello" à l'écran. @ENDNODE @NODE FindStr "Guide Hollywood" @{b}NOM@{ub} FindStr -- trouver une chaîne dans une chaîne @{b}SYNOPSIS@{ub} var=FindStr(string$,substring$[,casesensitive]) @{b}FONCTION@{ub} Recherches de la chaîne substring$ dans la chaîne string$ et renvois la position de la chaîne trouvée dans la variable var. Si la chaîne n'est pas trouvée, -1 est retourné. L'argument optionnel casesensitive (distinguo majuscules/minuscules) vous permet de spécifier si la recherche doit distinguer ou pas les lettres majuscules des minuscules (valeur par défaut: TRUE). @{b}INPUTS@{ub} string$ - chaîne ou la recherche doit être effectué substring$ - chaîne à trouver dans string$ casesensitive - TRUE pour une recherche distinguant les majuscules des minuscules (par défaut) ou FALSE pour une recherche sans distinguer les majuscules des minuscules @{b}RESULTATS@{ub} var - variable qui reçoit le résultat de la recherche @{b}EXEMPLE@{ub} test$="Hello World!" result=FindStr(test$,"World") Print(result) Ceci affichera " 6 " qui est la position du premier caractère "W". @ENDNODE @NODE Chr "Guide Hollywood" @{b}NOM@{ub} Chr -- convertir une valeur ASCII en une chaîne @{b}SYNOPSIS@{ub} var$=Chr(value) @{b}FONCTION@{ub} Convertit le caractère ASCII qui est décrit par le nombre value en une chaîne indiqué dans var$. @{b}INPUTS@{ub} value - valeur décrivant un caractère ASCII @{b}RESULTATS@{ub} var$= - chaine qui reçoit le résultat @{b}EXEMPLE@{ub} test$=Chr(65) Print(test$) Ceci affichera " A " à l'écran (65 = valeur ASCII pour " A "). @ENDNODE @NODE Asc "Guide Hollywood" @{b}NOM@{ub} Asc -- convertir le premier caractère d'une chaîne en valeur ASCII @{b}SYNOPSIS@{ub} var=Asc(string$) @{b}FONCTION@{ub} Renvoie la valeur ASCII du premier caractère dans la chaîne @{b}string$@{ub} dans la variable @{b}var@{ub}. @{b}INPUTS@{ub} string$ - chaîne dont le premier caractère sera converti @{b}RESULTATS@{ub} var - variable qui recoit la valeur ASCII @{b}EXEMPLE@{ub} result=Asc("A") Print(result) Ceci affichera " 65 ", qui est la valeur ASCII de " A ". @ENDNODE @NODE AddStr "Guide Hollywood" @{b}NOM@{ub} AddStr -- ajouter une chaîne dans une chaîne @{b}SYNOPSIS@{ub} var$=AddStr(string1$,string2$) @{b}FONCTION@{ub} Ajoute la chaîne string2$ à la suite de la chaîne string1$ et renvoie la nouvelle chaîne dans var$. Note: Vous pouvez également utiliser @{"l'opérateur de concaténation de chaîne" V6PrgOprStrng} pour une concaténation (ajout) de deux chaînes. @{b}INPUTS@{ub} string1$ - chaîne source string2$ - chaîne à ajouter @{b}RESULTATS@{ub} var$ - chaîne qui reçoit la nouvelle chaîne @{b}EXEMPLE@{ub} test$="Hello" test$=AddStr(test$," World!") Print(test$) Ceci affichera "Hello World!" @ENDNODE @NODE HexStr "Guide Hollywood" @{b}NOM@{ub} HexStr -- convertir une valeur en une chaîne hexadécimal (V1.5) @{b}SYNOPSIS@{ub} hex$ = HexStr(val) @{b}FONCTION@{ub} Cette commande convertit la valeur spécifiée par val dans le format hexadécimal et la renvois sous forme de chaîne. La chaîne retournée sera préfixée par un symbole dollar ($). @{b}INPUTS@{ub} val - valeur à convertir @{b}RESULTATS@{ub} hex$ - val dans la notation hexadécimale @{b}EXEMPLE@{ub} a$ = HexStr(255) La variable a$ recevrà la chaîne de caractères "$FF". @ENDNODE @NODE StrLen "Guide Hollywood" @{b}NOM@{ub} StrLen -- renvoie la longueur d'une chaîne @{b}SYNOPSIS@{ub} len = StrLen(str$) @{b}FONCTION@{ub} Cette commande renvoie la longueur de la chaîne spécifié par str$. @{b}INPUTS@{ub} str$ - chaîne d'entrée @{b}RESULTATS@{ub} len - longueur de la chaîne @{b}EXEMPLE@{ub} len = StrLen("Hello") Len sera égale à 5. @ENDNODE @NODE BinStr "Guide Hollywood" @{b}NOM@{ub} BinStr -- convertir une valeur en chaîne binaire (V2.0) @{b}SYNOPSIS@{ub} bin$ = BinStr(val[, length]) @{b}FONCTION@{ub} Cette commande convertit la valeur spécifiée par val en format binaire (base 2) et la renvois sous forme de chaîne. L'argument optionnel length vous permet de spécifier combien de bits seront mis dans la chaîne. Il peut être #INTEGER(entier) pour 32 bits, #SHORT(petit) pour 16 bits, et #BYTE(octet) pour 8 bits. Par défaut, #INTEGER sera utilisé. @{b}INPUTS@{ub} val - valeur à convertir length - optionnel: combien de bits seront convertis (soit #INTEGER, #SHORT, ou #BYTE) (V3.0) @{b}RESULTATS@{ub} bin$ - val dans en notation binaire @{b}EXEMPLE@{ub} a$ = BinStr(255, #BYTE) La variable a$ recevrà la chaîne " 11111111 ". @ENDNODE @NODE SplitStr "Guide Hollywood" @{b}NOM@{ub} SplitStr -- diviser une chaîne en plusieurs morceaux (V2.0) @{b}SYNOPSIS@{ub} table, count = SplitStr(src$, token$) @{b}FONCTION@{ub} Cette commande divise une chaîne spécifié par src$ en plusieurs morceaux en recherchant le séparateur token$ dans src$. token$ doit être une chaîne contenant un caractère qui agira en tant que séparateur dans la chaîne src$. SplitStr() renverra un tableau contenant tous les morceaux et numéro des morceaux dans la chaîne comme deuxième valeur de renvoi. Si token$ n'apparaît pas dans la chaîne source, src$ est retourné. @{b}INPUTS@{ub} src$ - chaîne à découper token$ - une chaîne contenant un argument de séparation @{b}RESULTATS@{ub} table - tableau où les nouvelles chaînes sont enregistrées count - nombre de chaînes que cette commande a produit @{b}EXEMPLE@{ub} array, c = SplitStr("AmigaOS3|MorphOS|AmigaOS4|WarpOS|AROS", "|") For k = 1 To c Do NPrint(array[k - 1]) Le code ci-dessus affichera AmigaOS3 MorphOS AmigaOS4 WarpOS AROS La variable c recevrà la valeur 5 parce que SplitStr() trouve 5 chaînes et les met dans le tableau spécifique. @ENDNODE @NODE PadNum "Guide Hollywood" @{b}NOM@{ub} PadNum -- convertir un nombre en une chaîne (V2.0) @{b}SYNOPSIS@{ub} s$ = PadNum(num, len) @{b}FONCTION@{ub} Cette commande convertit le nombre entier spécifié dans num en chaîne. De plus, cette commande ajoute des zéros jusqu'à ce que la chaîne ait la longueur spécifié par len caractère. Le nombre ne doit pas être négatif et ne doit pas contenir de décimale (nombre à virgule). @{b}INPUTS@{ub} num - nombre à convertir en chaîne len - longueur désirée de la chaîne @{b}RESULTATS@{ub} s$ - chaîne complétée @{b}EXEMPLE@{ub} DebugPrint(PadNum(9, 2)) Affiche "09". @ENDNODE @NODE StrToArray "Guide Hollywood" @{b}NOM@{ub} StrToArray -- convertir une chaîne en valeur ASCII (V2.0) @{b}SYNOPSIS@{ub} t = StrToArray(s$) @{b}FONCTION@{ub} Cette commande convertit la chaîne s$ et met les valeurs ASCII de chaque caractères de cette chaîne dans un tableau et les renvois. Le tableau aura autant d'éléments que la chaîne a de caractères plus un zéro dans sa terminaison. @{b}INPUTS@{ub} s$ - chaîne à convertir @{b}RESULTATS@{ub} t - un tableau contenant les valeurs ASCII des caractères de la chaîne @{b}EXEMPLE@{ub} t = StrToArray("Hello World") DebugPrint(Chr(t[6])) Affiche "W". @ENDNODE @NODE TrimStr "Guide Hollywood" @{b}NOM@{ub} TrimStr -- enlever/ajouter des caractères (V2.0) @{b}SYNOPSIS@{ub} s$ = TrimStr (src$, chr$, tail) @{b}FONCTION@{ub} Cette commande peut être utilisé pour enlever tous les caractères qui correspondent à chr$ dans l'entête ou le pied de la chaîne src$. La chaîne chr$ doit contenir un seul caractère. tail doit être réglé sur TRUE pour démarrer l'effacement à partir de la droite ou FALSE pour démarrer à partir du côté gauche. La chaîne enlevé sera retourné. @{b}INPUTS@{ub} src$ - chaîne à modifier chr$ - un caractère unique tail - TRUE ou FALSE qui indique où commencer @{b}RESULTATS@{ub} s$ - une chaîne modifié @{b}EXEMPLE@{ub} a$ = TrimStr("aaaaHello World", "a", False) DebugPrint(a$) Affiche "Hello World". --- a$ = TrimStr("aaaaHello Worldaaaa", "a", True) DebugPrint(a$) Affiche "aaaaHello World". @ENDNODE @NODE ToString "Guide Hollywood" @{b}NOM@{ub} ToString -- convertir n'importe quel type de donnée en chaîne (V2.0) @{b}SYNOPSIS@{ub} s$ = ToString(data) @{b}FONCTION@{ub} Cette commande peut convertir n'importe quel type de donnée en chaîne. Vous pouvez convertir des tableaux, fonctions, chaînes, numéros et Nil. ToString() est également utilisé par les commandes @{"Print()" LINK Print} et @{"DebugPrint()" LINK DebugPrint}. Ainsi vous pouvez afficher n'importe quels types de donnée. De plus, si vous ajoutez dans un tableau un nom de sous-tableau qui à comme titre "__tostring" ce tableau sera appelé. @{b}INPUTS@{ub} data - valeur à convertir en chaîne @{b}RESULTATS@{ub} s$ - une chaîne @{b}EXEMPLE@{ub} s$ = ToString(DisplayBrush) ; renvoie "Function: 74cd2456" s$ = ToString({1,2,3,4,5}) ; renvoie "Table: 74ab1344" s$ = ToString(Nil) ; renvoie "Nil" s$ = ToString(5) ; renvoie "5" s$ = ToString("Hello") ; renvoie "Hello" @ENDNODE @NODE ToNumber "Guide Hollywood" @{b}NOM@{ub} ToNumber -- convertir une chaîne en nombre (V2.0) @{b}SYNOPSIS@{ub} n = ToNumber(s$[, base]) @{b}FONCTION@{ub} Cette commande essaye de convertir une chaîne spécifié dans s$ en nombre. L'argument optionnel base peut être utilisé pour convertir en binaire, en octal, ou en nombre hexadécimal ou toutes autres bases s'échelonnant de 2 à 36 . La base par défaut est 10 (décimale). Dans les bases comprisent de 11 à 36 inclus, les lettres de l'alphabet sont utilisé comme chiffres complémentaires (10=A, 35=Z). @{b}INPUTS@{ub} s$ - chaîne à convertir base - optionnel: base de la conversion (valeur par défauts : 10) @{b}RESULTATS@{ub} number - nombre converti @{b}EXEMPLE@{ub} r = ToNumber("10000") ; renvois10000 r = ToNumber("10110111", 2) ; renvois183 r = ToNumber("523", 8) ; renvois 339 r = ToNumber("FFFF", 16) ; renvois 65535 @ENDNODE @NODE V6LibString "Guide Hollywood" @{b}Bibliothéque CHAINE@{ub} @{"AddStr() " LINK AddStr } ajouter une sous-chaîne à une chaîne @{"Asc() " LINK Asc } convertir le premier caractère d'une chaîne en valeur ASCII @{"BinStr() " LINK BinStr } convertir la valeur en chaîne binaire (V2.0) @{"Chr() " LINK Chr } convertir une valeur ASCII en une chaîne @{"FindStr() " LINK FindStr } FindStr -- trouver une sous-chaîne dans une chaîne @{"HexStr() " LINK HexStr } convertir une valeur en une chaîne hexadécimal (V1.5) @{"LeftStr() " LINK LeftStr } copie n caractères de l'extrême gauche d'une chaîne à une nouvelle chaîne @{"LowerStr() " LINK LowerStr } convertir tous les caractères dans une chaîne en lettre minuscule @{"MidStr() " LINK MidStr } extraire des caractères d'une chaîne @{"NPrint() " LINK NPrint } afficher les données et ajouter un retour à la ligne @{"PadNum() " LINK PadNum } convertir un nombre en une chaîne avec ajout (V2.0) @{"Print() " LINK Print } afficher des données à l'écran @{"ReplaceStr() " LINK ReplaceStr} remplacer une sous-chaîne par une autre chaîne @{"RightStr() " LINK RightStr } retourner les caractères de droite d'une chaîne vers une nouvelle chaîne @{"SplitStr() " LINK SplitStr } diviser une chaîne en plusieurs morceaux (V2.0) @{"StrLen() " LINK StrLen } renvoie la longueur d'une chaîne @{"StrStr() " LINK StrStr } convertir un nombre en chaîne @{"StrToArray() " LINK StrToArray} convertir une chaîne en valeur ASCII (V2.0) @{"ToNumber() " LINK ToNumber } convertir une chaîne en nombre (V2.0) @{"ToString() " LINK ToString } convertir n'importe quel type de donnée en chaîne (V2.0) @{"TrimStr() " LINK TrimStr } enlever/ajouter des caractères (V2.0) @{"UnleftStr() " LINK UnleftStr } retirer n caractère(s) à l'extrême droite d'une chaîne @{"UnrightStr() " LINK UnrightStr} retirer n caractère(s) à l'extrême gauche d'une chaîne @{"UpperStr() " LINK UpperStr } convertir une chaîne en majuscule @{"Val() " LINK Val } convertir une chaîne en nombre @ENDNODE @NODE GetDate "Guide Hollywood" @{b}NOM@{ub} GetDate -- obtenir une chaîne contenant la date @{b}SYNOPSIS@{ub} date$=GetDate() @{b}FONCTION@{ub} Cette commande retourne la date dans une chaîne au format du lieu de l'utilisateur. Par exemple sur un système localisé en Allemagne la date ressemble à "04.09.02" mais sur un système aux USA elle ressemble à "09.04.02". Si vous devez obtenir des informations sur le jour, le mois et l'année en cours sous forme de nombre, mieux vaut utiliser la commande @{"GetDateNum()" LINK GetDateNum}. @{b}INPUTS@{ub} aucun @{b}RESULTATS@{ub} date$ - current date @ENDNODE @NODE GetDateNum "Guide Hollywood" @{b}NOM@{ub} GetDateNum -- obtenir l'information de la date @{b}SYNOPSIS@{ub} info=GetDateNum(id) @{b}FONCTION@{ub} Cette commande vous permet d'obtenir l'information de la date. Les constantes suivantes peuvent être utilisées comme id: #DATEDAY : retourne le jour du mois (1-31) #DATEMONTH : retourne le mois (1-12) #DATETIME : retourne le temps (00hhmmss) #DATEYEAR : retourne l'année (20xx) @{b}INPUTS@{ub} id - une des constantes comme indiquée ci-dessus @{b}RESULTATS@{ub} info - l'information de jour, de mois ou d'année @ENDNODE @NODE GetMemoryInfo "Guide Hollywood" @{b}NOM@{ub} GetMemoryInfo -- obtenir des informations sur la mémoire @{b}SYNOPSIS@{ub} space=GetMemoryInfo(id) @{b}FONCTION@{ub} Cette commande retourne des informations sur la quantité de mémoire de votre système. Les constantes suivantes peuvent être indiquées comme id: #CHIPMEMORY : retourne la quantité de mémoire Chip #FASTMEMORY : retourne la quantité de mémoire Fast @{b}INPUTS@{ub} id - une des constantes comme indiquée ci-dessus @{b}RESULTATS@{ub} space - espace mémoire @{b}EXEMPLE@{ub} chip=GetMemoryInfo(#CHIPMEMORY) fast=GetMemoryInfo(#FASTMEMORY) Print("Vous avez", chip, "Octet de mémoire Chip et", fast, "Octet de mémoire Fast!") Le code ci-dessus affiche la quantité de mémoire Chip et Fast @ENDNODE @NODE GetTime "Guide Hollywood" @{b}NOM@{ub} GetTime -- obtenir l'heure en cours @{b}SYNOPSIS@{ub} time$=GetTime([secs]) @{b}FONCTION@{ub} Cette commande va chercher l'heure en cours et la retourne dans time$. Si l'argument optionnel sec est défini avec TRUE, Hollywood ajoutera également les secondes dans la chaîne. @{b}INPUTS@{ub} sec - optionnels : indiquer TRUE si vous voulez également les secondes @{b}RESULTATS@{ub} time$ - chaîne contenant l'heure actuel @ENDNODE @NODE GetWeekday "Guide Hollywood" @{b}NOM@{ub} GetWeekday -- obtenir le jour de la semaine @{b}SYNOPSIS@{ub} day$=GetWeekday() @{b}FONCTION@{ub} Cette commande retourne le jour de la semaine dans la chaîne day$. Noter que le jour de la semaine sera retourné dans le langage natif de l'utilisateur (selon ses réglages de lieu). @{b}INPUTS@{ub} aucun @{b}RESULTATS@{ub} day$ - jour de la semaine actuel @ENDNODE @NODE OpenCatalog "Guide Hollywood" @{b}NOM@{ub} OpenCatalog -- ouvrir un catalogue @{b}SYNOPSIS@{ub} OpenCatalog(name$[,version]) @{b}FONCTION@{ub} Cette commande essaie d'ouvrir un catalogue défini par name$ dans la langue de l'utilisateur. Si il n'existe pas de catalogue dans la langue de l'utilisateur, cette commande n'échouera pas. Vous devez spécifier la langue anglaises comme alternative dans la commande GetCatalogString() qui sera utilisé s'il n'y a aucun catalogue dans la langue de l'utilisateur. @{b}INPUTS@{ub} name$ - catalogue à ouvrir version - optionnel: version minimum du catalogue demandé; si vous ne l'indiquez pas, cette commande acceptera n'importe quelle version @{b}EXEMPLE@{ub} OpenCatalog("Hollywood.catalog") ; c'est notre catalogue anglais par défaut def$[0]="Welcome to Hollywood!" def$[1]="Written by Andreas Falkenhahn" def$[2]="What do you wanna do?" ; si Hollywood.catalog n'est pas disponible dans ; le langage de l'utilisateur ; les chaînes de caractères anglaises seront ; utilisé For k = 0 To 2 c$[k]=GetCatalogString(k,def$[k]) Next CloseCatalog() @ENDNODE @NODE CloseCatalog "Guide Hollywood" @{b}NOM@{ub} CloseCatalog -- fermer un catalogue ouvert @{b}SYNOPSIS@{ub} CloseCatalog() @{b}FONCTION@{ub} Cette commande fermera le catalogue ouvert précédemment. Vous n'avez pas réellement besoin d'utiliser cette commande, puisque Hollywood fermera le catalogue automatiquement lorsqu'il sera arrêté. @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} Voir @{"OpenCatalog()" LINK OpenCatalog} @ENDNODE @NODE GetCatalogString "Guide Hollywood" @{b}NOM@{ub} GetCatalogString -- obtenir une chaîne d'un catalogue @{b}SYNOPSIS@{ub} s$=GetCatalogString(id,default$) @{b}FONCTION@{ub} Cette commande extrait la chaîne définie par id à partir du fichier catalogue précédemment ouvert. Si il n'y a aucun catalogue qui est ouvert, la chaîne spécifié dans default$ est retournée. @{b}INPUTS@{ub} id - spécifie quelle chaîne est à retourner (à partir de 0) default$ - chaîne à retourner s'il n'y a aucun catalogue ouvert ou si il n'y a aucune chaîne avec l'id spécifié @{b}EXEMPLE@{ub} see @{"OpenCatalog()" LINK OpenCatalog} @ENDNODE @NODE StartTimer "Guide Hollywood" @{b}NOM@{ub} StartTimer -- démarrer un nouveau chronomètre @{b}SYNOPSIS@{ub} [id] = StartTimer(id) @{b}FONCTION@{ub} Cette commande créé un nouveau chronomètre et lui affecte l'identification id. Si vous indiquez @{"Nil" LINK V6PrgTypeNil} comme identification, StartTimer() choisira automatiquement une i dentification vide et la retournera. Ce chronomètre fonctionnera jusqu'à ce que vous indiquiez @{"PauseTimer()" LINK PauseTimer} ou @{"StopTimer()" LINK StopTimer}. Vous pouvez obtenir l'état actuel du chronomètre en appelant @{"GetTimer()" LINK GetTimer}. @{b}INPUTS@{ub} id - identification pour votre chronomètre ou @{"Nil" LINK V6PrgTypeNil} pour la @{"sélection automatique d'id" LINK AutoIDSelect} @{b}RESULTATS@{ub} id - optionnel: identificateur du chronomètre; sera seulement retourné quand vous définirez @{"Nil" LINK V6PrgTypeNil} dans l'argument id (voir ci-dessus) @{b}EXEMPLE@{ub} StartTimer(1) Wait(200) t=GetTimer(1) Print(t) Le code ci-dessus commence un nouveau compteur, attend 4 secondes et interroge l'état du compteur. Le temps du chronomètre est copié dans la variable t et devrait avoir la valeur de 4000 millisecondes. @ENDNODE @NODE StopTimer "Guide Hollywood" @{b}NOM@{ub} StopTimer -- arrêter un chronomètre @{b}SYNOPSIS@{ub} StopTimer (id) @{b}FONCTION@{ub} Cette commande arrête le chronomètre spécifié par id. Si vous vous stopper un chronomètre, il sera complètement retiré du système, pour cette raison vous ne pouvez pas le faire reprendre. Si vous voulez effectuer une pause sur un chronomètre, utiliser @{"PauseTimer()" LINK PauseTimer}. @{b}INPUTS@{ub} id - identification du chronomètre qui sera arrêté @{b}EXEMPLE@{ub} voir @{"StartTimer()" LINK StartTimer} @ENDNODE @NODE GetTimer "Guide Hollywood" @{b}NOM@{ub} GetTimer -- obtenir le temps d'un chronomètre @{b}SYNOPSIS@{ub} state=GetTimer(id) @{b}FONCTION@{ub} Cette commande retourne le temps à l'instant demandé du chronomètre, qui est le temps qui s'est écoulé depuis que le chronomètre a débuté avec @{"StartTimer()" LINK StartTimer}. Le temps est retourné en millisecondes. @{b}INPUTS@{ub} id - identification du chronomètre à interroger afin de connaitre son état @{b}RESULTATS@{ub} state - temps en millisecondes qui sont passé depuis que le chronomètre a démarrer (en ce qui concerne @{"PauseTimer()" LINK PauseTimer} et @{"ResumeTimer()" LINK ResumeTimer}) @{b}EXEMPLE@{ub} voir @{"StartTimer()" LINK StartTimer} @ENDNODE @NODE PauseTimer "Guide Hollywood" @{b}NOM@{ub} PauseTimer -- effectuer une pause sur un chronomètre @{b}SYNOPSIS@{ub} PauseTimer(id) @{b}FONCTION@{ub} Cette commande effectue une pause sur le chronomètre spécifié par id. Quand un chronomètre est mis en pause, il ne compte pas le temps mais vous pouvez encore obtenir le temps du chronomètre par l'intermédiaire de @{"GetTimer()" LINK GetTimer}. Le chronomètre peut être repris en utilisant @{"ResumeTimer()" LINK ResumeTimer}. @{b}INPUTS@{ub} id - identification du chronomètre à mettre en pause @{b}EXEMPLE@{ub} aucun @ENDNODE @NODE ResumeTimer "Guide Hollywood" @{b}NOM@{ub} ResumeTimer -- reprendre un chronomètre qui est en pause @{b}SYNOPSIS@{ub} ResumeTimer(id) @{b}FONCTION@{ub} Cette commande fait reprendre le chronomètre spécifié par id. Le chronomètre doit être en pause (indiquer par @{"PauseTimer()" LINK PauseTimer}). Si ResumeTimer() fonctionne, le chronomètre reprend. @{b}INPUTS@{ub} id - identification du chronomètre à reprendre @{b}EXEMPLE@{ub} aucun @ENDNODE @NODE Sort "Guide Hollywood" @{b}NOM@{ub} Sort -- trier un tableau @{b}SYNOPSIS@{ub} Sort(array) @{b}FONCTION@{ub} Cette commande trie le tableau spécifié par la variable array. Il supporte les tableau de type @{"nombre" LINK V6PrgTypeNumber} et de type @{"chaîne" LINK V6PrgTypeString}. Mais les types ne doivent pas être mélangés. Cette commande cesse de trier s'il trouve un élément @{"Nil" LINK V6PrgTypeNil} ou une chaîne vide ("") dans le tableau. Les tableaux de chaîne sont triés alphabétiquement, les tableaux de nombre sont triés dans l'ordre croissant. @{b}INPUTS@{ub} array - tableau à trier @{b}EXEMPLE@{ub} names = {"Joey", "Dave", "Mark", "Stephen", "Al", "Jefferson"} Sort(names) For k = 0 To 5 NPrint(names[k]) Next Le code ci-dessus définit un tableau, ajoute quelques noms et le tris. La sortie est " Al, Dave, Jefferson, Joey, repère, Stephen ". @ENDNODE @NODE DebugOutput "Guide Hollywood" @{b}NOM@{ub} DebugOutput -- activer/désactiver la sortie de débuggage @{b}SYNOPSIS@{ub} DebugOutput(enable) @{b}FONCTION@{ub} Cette commande active ou désactive la fonction d'affichage de débuggage vers le dispositif de débuggage par défaut. Si la sortie de débuggage est activée (TRUE), Hollywood affichera l'information au sujet de n'importe quel commande qui est appelé, ainsi vous pouvez facilement dépister les problèmes. @{b}INPUTS@{ub} enable - TRUE pour activer la sortie de débuggage, FALSE pour la désactiver @{b}EXEMPLE@{ub} DebugOutput(TRUE) Le code ci-dessus permet d'activer la sortie de débuggage @ENDNODE @NODE ExitOnError "Guide Hollywood" @{b}NOM@{ub} ExitOnError -- activer/désactiver le gestionnaire automatique d'erreurs @{b}SYNOPSIS@{ub} ExitOnError(enable) @{b}FONCTION@{ub} Cette commande active ou désactive le gestionnaire automatique d'erreurs d'Hollywood. Si le gestionnaire automatique d'erreurs est activé, il vérifiera chaque commande qui est exécuté, pour vérifier si une erreur s'est produite ou si éventuellement il y en a une, l'exécution de votre script sera interrompu et Hollywood affichera le message d'erreur. Vous ne devriez pas désactiver le gestionnaire automatique d'erreurs. Si vous le désactivé, vous devrez vérifier manuellement si certaines de vos commandes échoue en utilisant @{"GetLastError()" LINK GetLastError} et @{"GetErrorName()" LINK GetErrorName}. C'est bien plus de travail. @{b}INPUTS@{ub} enable - TRUE pour activer le gestionnaire automatique d'erreurs; FALSE pour le désactiver @ENDNODE @NODE GetLastError "Guide Hollywood" @{b}NOM@{ub} GetLastError -- obtenir Le code erreur de la dernière commande @{b}SYNOPSIS@{ub} code=GetLastError() @{b}FONCTION@{ub} Cette commande interroge les codes d'erreur interne d'Hollywood et retourne le résultat. Ce code est égal à zéro si la dernière commande accomplie a fonctionné. Si la commande échoue, un code d'erreur qui n'est pas égal à zéro sera retourné. Ce code d'erreur ne peut être utilisé pour interroger Hollywood afin d'obtenir une chaîne qui décrit l'erreur qui s'est produite. (utiliser @{"GetErrorName()" LINK GetErrorName}) Note importante: Les codes d'erreurs interne Hollywood seront remis à l'état initial (0) avant qu'une commande soit exécuté. Par conséquent, le code d'erreur que vous obtiendrez quand vous exécuterez GetLastError() sera le code d'erreur d'une commande qui a été appelé avant GetLastError(). Note importante #2: Cette commande est seulement utile si le gestionnaire automatique d'erreurs est désactivé. Si il est activé (par défaut), le gestionnaire automatique d'erreurs arrêtera votre script immédiatement quand l'erreur se produira. Votre script n'obtiendra jamais un appel de GetLastError() si une erreur se produisait et que le gestionnaire automatique d'erreurs était activé. Par conséquent vous devrez indiquer FALSE à @{"ExitOnError()" LINK ExitOnError} comme indicateur pour désactiver le gestionnaire automatique d'erreurs de Hollywood. @{b}INPUTS@{ub} aucun @{b}RESULTATS@{ub} code - différent de zéro si une erreur se produisait, zéro si aucune erreur @{b}EXEMPLE@{ub} ExitOnError(FALSE); gestionnaire automatique d'erreurs désactiver LoadBGPic(1,"ram:blablabla"); cette commande échouera! code=GetLastError() If(code<>0) err$=GetErrorName(code) SystemRequest("une erreur s'est produite!",err$,"OK") End EndIf Le code ci-dessus montre comment traiter l'erreur produit par LoadBGPic(). Il est important qu'il n'y ait aucune autre commande entre LoadBGPic() et GetLastError(). S'il y avait une autre commande, les résultats de l'erreur de LoadBGPic() seraient effacés. @ENDNODE @NODE GetErrorName "Guide Hollywood" @{b}NOM@{ub} GetErrorName -- obtenir la chaîne définissant le code d'erreur @{b}SYNOPSIS@{ub} err$=GetErrorName(code) @{b}FONCTION@{ub} Cette commande retourne une chaîne définissant le code d'erreur. La chaîne décrit l'erreur pour Le code transmis. Cette commande doit être exécuter bien après @{"GetLastError()" LINK GetLastError} parce que la chaîne d'erreur pourrait contenir une information qui serait effacé quand la commande suivante serait exécuté. Exécuter une commande conditionnelle entre @{"GetLastError()" LINK GetLastError} et GetErrorName() ne pause aucun problème. Voir l'exemple pour plus d'information. Lire également la documentation de la commande @{"GetLastError()" LINK GetLastError} pour plus d'informations détaillées sur le traitement manuel des erreurs. @{b}INPUTS@{ub} code - un code erreur retourné par @{"GetLastError()" LINK GetLastError} @{b}RESULTATS@{ub} err$ - une chaîne décrivant l'erreur produite @{b}EXEMPLE@{ub} voir @{"GetLastError()" LINK GetLastError} @ENDNODE @NODE DebugPrint "Guide Hollywood" @{b}NOM@{ub} DebugPrint -- afficher l'information de débogage (V2.0) @{b}FORMERLY KNOWN AS@{ub} DebugVal (V1.x) DebugStr (V1.x) @{b}SYNOPSIS@{ub} DebugPrint(...) @{b}FONCTION@{ub} Cette commande affiche tous les arguments que vous avez spécifié pour le dispositif de débogage, c'est habituellement votre fenêtre console. Vous pouvez spécifier autant d'arguments que vous le voulez et également n'importe quel type. Si vous obtenez plusieurs arguments avec cette commande, ils seront affichés avec un espace en guise de séparation. Cette commande remplace les commandes DebugStr() et DebugVal(). Maintenant, il pointe simplement cet appel. @{b}INPUTS@{ub} .. - au moins une valeur à afficher au dispositif de débogage @{b}EXEMPLE@{ub} DebugPrint("l'utilisateur a entré ", name$, " pour son nom et ", age$, " pour son age!") @ENDNODE @NODE InsertItem "Guide Hollywood" @{b}NOM@{ub} InsertItem -- insérer un item dans une liste (V2.0) @{b}SYNOPSIS@{ub} InsertItem(array, item[, pos]) @{b}FONCTION@{ub} Cette commande insère un item spécifié par item dans un tableau spécifié par array. L'item peut être de n'importe quel type. Si vous ne spécifiez pas l'argument optionnel de position pos, l'item sera ajoutée à la fin de la liste. Si vous spécifiez l'argument de position pos, l'item sera inséré à cette position et tous les item qui succèdent seront déplacé d'une position. Le compteur de position débute à 0 qui est le premier item. @{b}INPUTS@{ub} array - tableau où insérer l'item item - item à insérer (peut être de n'importe quel type) pos - optionnel: où insérer (défauts à -1 se qui signifie en fin de liste) @{b}EXEMPLE@{ub} a = {1, 2, 3, 4, 5, 7, 8, 9, 10} InsertItem(a, 6, 5) For k = 1 To ListItems(a) Do Print(a[k - 1] .. " ") Prints "1 2 3 4 5 6 7 8 9 10". L'item "6" est inséré à la position 5 de sorte que la rangée soit complète. @ENDNODE @NODE RemoveItem "Guide Hollywood" @{b}NOM@{ub} RemoveItem -- retirer un item d'une liste (V2.0) @{b}SYNOPSIS@{ub} e = RemoveItem(array[, pos]) @{b}FONCTION@{ub} Cette commande retire un item d'une liste et le retourne. Si vous n'indiquez pas l'argument optionnel de position pos, le dernier item de la liste sera retirée. Autrement l'item spécifié est retiré. La position 0 spécifie le premier item de la liste. Après avoir retiré l'item, le tableau est réorganisé et comble l'écartement(espace vide). @{b}INPUTS@{ub} tableau - tableau d'où retirer l'élément pos - optionnel: item qui doit être retiré (par défauts à -1 se qui signifie que le dernier élément doit être retiré) @{b}RESULTATS@{ub} e - l'item qui a été retiré @{b}EXEMPLE@{ub} a = {1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 10} e = RemoveItem(a, 7) For k = 1 To ListItems(a) Do Print(a[k - 1] .. " ") Retire le nombre 8 parce qu'il est deux fois dans la liste. La variable e recevra la valeur 8. Après avoir retiré l'item, la rangée correcte sera affiché: " 1 2 3 4 5 6 7 8 9 10 ". @ENDNODE @NODE ListItems "Guide Hollywood" @{b}NOM@{ub} ListItems -- compter le nombre d'item d'une liste (V2.0) @{b}SYNOPSIS@{ub} c = ListItems(array) @{b}FONCTION@{ub} Cette commande comptabilise tous les items d'une liste et retourne la quantitée d'item dans la liste. Le compteur s'arrêtera quand un élément de type @{"Nil" LINK V6PrgTypeNil} est trouvé dans la liste. @{b}INPUTS@{ub} array - tableau dont les items doivent être comptabilisés @{b}RESULTATS@{ub} c - compteur @{b}EXEMPLE@{ub} Print(ListItems({1, 2, 3, 4, 5, 6, 7, 8, 9, 10})) Ce code retourne 10. @ENDNODE @NODE Unpack "Guide Hollywood" @{b}NOM@{ub} Unpack -- décompresser un tableau (V2.0) @{b}SYNOPSIS@{ub} a, ... = Unpack(t) @{b}FONCTION@{ub} Cette commande décompresse le tableau spécifié par t et retourne l'intégralité de ses éléments. Unpack() retourne autant de valeurs qu'il y a d'éléments dans le tableau. @{b}INPUTS@{ub} t - tableau à décompresser @{b}RESULTATS@{ub} a - première valeur .. - valeurs de renvoi supplémentaires selon le nombre d'élémentsqu'il y a dans le tableau @{b}EXEMPLE@{ub} a, b, c = Unpack({1, 2, 3}) Le code ci-dessus éclate le tableau spécifié. "a" obtiendrà la valeur 1, "b" sera affecté 2 et "c" recevrà la valeur 3. ----------------------------------------------------------------------- a = {1, 2, 3, 4, 5, 6} Print(Unpack(a)) Ceci affichera " 1 2 3 4 5 6 ". @ENDNODE @NODE SetPointer_Old "Guide Hollywood" @{b}NOM@{ub} SetPointer -- installer un nouveau pointeur de souris (V1.5) @{b}SYNOPSIS@{ub} SetPointer(file$[, x, y]) @{b}NOTE IMPORTANTE@{ub} Cette commande a changé, cette fonctionnalité a débuté avec Hollywood 4.0. Voir cette nouvelle commande @{"ici" LINK SetPointer}. @{b}FONCTION@{ub} Cette commande vous permet d'installer votre propre pointeur de souris. Hollywood chargera l'image spécifié par file$ en tant que pointeur de souris. Les arguments optionnels x et y spécifie la position du point de contact sur le pointeur. La valeur par défaut est à 0:0, se qui signifie le coin en haut à gauche de l'image. Note: Votre image doit avoir 4 couleurs et ne doit pas être plus large que 16 Pixel. Les couleurs de votre image de pointeur ne sont pas installé parce que le pointeur intuition utilise la palette d'entrées de l'écran utilisé (entrées 17 à 19). @{b}INPUTS@{ub} file$ - image du pointeur X - optionnel: point x de contact (défauts à 0) y - optionnel: point y de contact (défauts à 0) @ENDNODE @NODE SetPointer "Guide Hollywood" @{b}NOM@{ub} SetPointer -- afficher un nouveau pointeur de souris (V4.0) @{b}SYNOPSIS@{ub} SetPointer(id) @{b}FONCTION@{ub} Cette commande affiche le pointeur de souris spécifié par id. Le pointeur de souris doit avoir été précédemment créé avec @{"CreatePointer()" LINK CreatePointer}. Note: Cette commande a eu une fonctionnalité différente jusqu'à Hollywood 4.0. Vous pouvez lire la commande originel de SetPointer() @{"ici" LINK SetPointer_Old}. @{b}INPUTS@{ub} id - identification du pointeur de souris à afficher @{b}EXEMPLE@{ub} voir @{"CreatePointer" LINK CreatePointer} @ENDNODE @NODE HidePointer "Guide Hollywood" @{b}NOM@{ub} HidePointer -- cacher le pointeur de souris @{b}SYNOPSIS@{ub} HidePointer() @{b}FONCTION@{ub} Cette commande cache le pointeur de la souris. Utiliser cette commande avec précaution parce qu'elle pourrait déstabiliser l'utilisateur. Vous pourrez de nouveau afficher le pointeur à l'écran en utilisant @{"ShowPointer()" LINK ShowPointer}. @{b}INPUTS@{ub} aucun @ENDNODE @NODE ShowPointer "Guide Hollywood" @{b}NOM@{ub} ShowPointer -- afficher le pointeur de souris @{b}SYNOPSIS@{ub} ShowPointer() @{b}FONCTION@{ub} Cette commande affiche le pointeur de souris après qu'il ait été caché avec @{"HidePointer()" LINK HidePointer}. @{b}INPUTS@{ub} aucun @ENDNODE @NODE MovePointer "Guide Hollywood" @{b}NOM@{ub} MovePointer -- déplacer le pointeur de souris @{b}SYNOPSIS@{ub} MovePointer(x, y) @{b}FONCTION@{ub} Cette commande déplace le pointeur de la souris à l'emplacement spécifié par x:y. Utiliser cette commande avec soin, parce qu'elle pourrait déstabiliser l'utilisateur. @{b}INPUTS@{ub} x - nouvelle position x désirée du pointeur y - nouvelle position y désirée du pointeur @{b}EXEMPLE@{ub} MovePointer(#CENTER, #CENTER) Le code ci-dessus déplace le pointeur au centre de votre écran. @ENDNODE @NODE AllocMem "Guide Hollywood" @{b}NOM@{ub} AllocMem -- allouer une nouvelle place mémoire (V2.0) @{b}SYNOPSIS@{ub} [id] = AllocMem(id, size) @{b}FONCTION@{ub} Cette commande alloue une nouvelle place de mémoire de la taille spécifié et la rend disponible sous l'identification id, ou, si vous indiquez @{"Nil" LINK V6PrgTypeNil} comme id, AllocMem() choisira automatiquement une identification vide et la retournera. La mémoire ne sera pas initialisé et sera donc rempli de donnée aléatoire. Si vous voulez l'initialiser à zéro, utiliser la commande @{"FillMem()" LINK FillMem}. @{b}INPUTS@{ub} id - identificateur pour l'espace mémoire ou @{"Nil" LINK V6PrgTypeNil} pour la @{"sélection automatique d'Id" LINK AutoIDSelect} size - taille de l'espace mémoire en octets @{b}RESULTATS@{ub} id - optionnel: identificateur de l'espace mémoire; sera seulement retourné quand vous indiquerez @{"Nil" LINK V6PrgTypeNil} comme argument 1 (voir ci-dessus) @ENDNODE @NODE FreeMem "Guide Hollywood" @{b}NOM@{ub} FreeMem -- libérer un espace mémoire (V2.0) @{b}SYNOPSIS@{ub} FreeMem(id) @{b}FONCTION@{ub} Cette commande libère la mémoire occupée du bloc spécifié par id @{b}INPUTS@{ub} id - bloc de mémoire à libérer @ENDNODE @NODE FillMem "Guide Hollywood" @{b}NOM@{ub} FillMem -- remplir un bloc mémoire (V2.0) @{b}SYNOPSIS@{ub} FillMem(id, val, size[, offset, type]) @{b}FONCTION@{ub} Cette commande peut être utilisé pour remplir entièrement un bloc mémoire ou en partie avec une valeur spécifié. L'identification id spécifie le bloc mémoire à utiliser, val est la valeur à utiliser pour remplir et size,la taille spécifie en octets pour l'opération de remplissage. Vous pouvez utiliser l'argument optionnel offset afin d'affiner l'opération de remplissage en spécifiant un décalage dans le bloc mémoire (en octets). type spécifie le type de la valeur, elle peut être #BYTE (1 octet), #SHORT (2 octets) ou #INTEGER (4 octets). Si vous utilisez #SHORT ou #INTEGER comme type de remplissage, la taille d'argument doit être un multiple de 2 ou de 4 . En outre, le décalage, si spécifié, doit être un multiple de 2 ou de 4. @{b}INPUTS@{ub} id - bloc mémoire à utiliser val - valeur pour remplir le bloc size - taille de l'opération de remplissage en octets; doit être un multiple de 2 ou de 4 si le type est #SHORT ou #INTEGER offset - optionnel: décalage dans le bloc la où le remplissage devra commencer (défauts à 0, se qui signifie le début du bloc); doit être un multiple de 2 ou de 4 si le type est #SHORT ou #INTEGER type - optionnel: type de val; actuellement supportés: #BYTE, #SHORT et #INTEGER (défauts à #BYTE) @{b}EXEMPLE@{ub} AllocMem(1, 65536) FillMem(1, 0, 65536) Allouer un bloc de 64kb et l'initialiser à 0. @ENDNODE @NODE CopyMem "Guide Hollywood" @{b}NOM@{ub} CopyMem -- copier les données entre des blocs mémoire (V2.0) @{b}SYNOPSIS@{ub} CopyMem(src, dst, size[, src_offset, dst_offset]) @{b}FONCTION@{ub} Cette commande copie des octets de la taille du bloc mémoire identifié par src au bloc identifié par dst à partir de src_offset du bloc source à dst_offset dans le bloc de destination. Noter que src et dst ne doivent pas être les mêmes blocs. @{b}INPUTS@{ub} src - bloc mémoire source dst - bloc mémoire destination size - taille en octets à copier src_offset - optionnel: décalage dans le bloc source, détermine d'où doit commencer la lecture (par défauts à 0 se qui veux dire au début du bloc) dst_offset - optionnel: décalage dans le bloc de destination, détermine d'où doit commencer l'enregistrement (par défauts à 0 se qui veut dire au début du bloc) @ENDNODE @NODE DumpMem "Guide Hollywood" @{b}NOM@{ub} DumpMem -- vider le contenu d'un bloc mémoire (V2.0) @{b}SYNOPSIS@{ub} DumpMem(id[, len, offset]) @{b}FONCTION@{ub} Cette commande vide le contenu d'un bloc mémoire spécifié par id dans le dispositif de débogage (habituellement une fenêtre console). L'argument optionnel len vous permet de spécifier la longueur en octets qui devra être vidés. S'il est omis, la totalité du bloc sera vidé. L'argument optionnel Offset peut être utilisé pour commencer à vider depuis un décalage à l'intérieur du bloc. En raison des données brutes qui sont habituellement dans ces blocs mémoire, Hollywood effectuera une vidange mémoire en hexadécimale incluant la notation ASCII (si possible). le format est le suivant : xxxxxxxx: bb bb bb bb bb bb bb bb bb bb bb bb bb bb bb bb cccccccccccccccc x : décalage dans la notation hexadécimale b : 16 octets par ligne c : les 16 octets seront dans la notation ASCII ou " . " si le caractère n'est pas graphique @{b}INPUTS@{ub} id - identificateur du bloc mémoire à vider len - optionnel: longueur en octets (défauts à 0, cela signifie que le bloc sera complètement vidée) offset - optionnel: décaler dans le bloc d'où il doit commencer à vider (par défauts à 0 = début du bloc) @ENDNODE @NODE Peek "Guide Hollywood" @{b}NOM@{ub} Peek -- lire à l'intérieur d'un bloc mémoire (V2.0) @{b}SYNOPSIS@{ub} r = Peek(id, offset[, type, len]) @{b}FONCTION@{ub} Cette commande vous permet de lire à l'intérieur d'un bloc mémoire à l'offset (emplacement) spécifié. type spécifie le type de données que vous voulez lire. Celui_ci peut être le #BYTE, #SHORT, #INTEGER ou #STRING. #BYTE lira un octet du bloc, #SHORT lira deux octets, #INTEGER quatre octets et #STRING lira dans le bloc mémoire jusqu'à ce qu'il rencontre un caractère non graphique ou un caractère nul. Depuis Hollywood 2.5, vous pouvez spécifier l'argument optionnel len. Cet argument peut seulement être utilisé avec le type #STRING. Si il est spécifié, Peek() lira len octets dans le bloc mémoire spécifié et le retournera sous forme de chaîne., Vous pouvez l'utiliser pour afficher des données brutes provenant de bloc mémoire puisque peek() ne se terminera pas sur un caractère non graphique ou nuls si len est spécifiés. Si len est égal à 0, qui est le paramètre par défaut, Peek() lira les octets jusqu'à ce qu'il rencontre un caractère non graphique ou nul. @{b}INPUTS@{ub} id - identificateur du bloc mémoire à utiliser offset - où lire (décalage en octets) type - optionnel: type de données à lire (défauts sur #INTEGER) len - optionnel: nombre d'octets à lire (fonctionne seulement avec le type #STRING) (défauts à 0 se qui signifie une lecture jusqu'a ce qu'il rencontre un caractère non graphique ou nul) (V2.5) @{b}RESULTATS@{ub} r - contenu du bloc mémoire au décalage spécifié; peut être une valeur ou une chaîne (si le type est réglé à #STRING) @ENDNODE @NODE Poke "Guide Hollywood" @{b}NOM@{ub} Poke -- écrire dans un bloc mémoire (V2.0) @{b}SYNOPSIS@{ub} Poke(id, offset, val[, type]) @{b}FONCTION@{ub} Cette commande écrit la valeur ou la chaîne spécifié dans val au bloc mémoire avec l'identification id à l'emplacement spécifié. Le type par défauts est #INTEGER et spécifie le type pour val. Pour le type #BYTE, val peut être dans la fourchette de 0 à $FF, pour le type #SHORT, de 0 à $FFFF et pour le type #INTEGER, de 0 à $FFFFFFFF. Ecrire une chaîne dans un bloc mémoire occupe le nombre de caractères dans la chaîne plus 1 octet. @{b}INPUTS@{ub} id - identificateur du bloc mémoire à utiliser offset - où écrire (en octets) val - données à écrire; peut être une chaîne ou un nombre type - optionnel: type de données à écrire (par défauts: #INTEGER) @{b}EXEMPLE@{ub} AllocMem(1, 1024) Poke(1, 0, "Hello World!", #STRING) Print(Peek(1, 0, #STRING)) Ceci affichera "Hello World!" a l'écran. @ENDNODE @NODE ReadMem "Guide Hollywood" @{b}NOM@{ub} ReadMem -- lire les données brutes à partir d'un fichier (V2.0) @{b}SYNOPSIS@{ub} ReadMem(file_id, blk_id, len[, offset]) @{b}FONCTION@{ub} Cette commande vous permet de lire len octets de données brutes d'un fichier ouvert (spécifié par file_id, utiliser @{"OpenFile()" LINK OpenFile} pour ouvrir un fichier) dans un bloc mémoire (spécifié par blk_id). De plus vous pouvez spécifier l'argument optionnel offset pour définir où dans le bloc mémoire les données brutes seront enregistrées. Les données à partir du fichier source sont lues à partir de la position du curseur dans le fichier que vous pouvez modifier en utilisant la commande @{"Seek()" LINK Seek} @{b}INPUTS@{ub} file_id - identificateur d'un fichier ouvert blk_id - identificateur d'un bloc mémoire len - octets à lire à partir du fichier offset - optionnel: où enregistrer les données dans le bloc mémoire (défauts à 0 = début du bloc) @{b}EXEMPLE@{ub} len = FileSize("C:SetPatch") OpenFile(1, "C:SetPatch", #MODE_READ) AllocMem(1, len) ReadMem(1, 1, len) CloseFile(1) OpenFile(1, "Ram:Copy_of_SetPatch", #MODE_WRITE) WriteMem(1, 1, len) CloseFile(1) FreeMem(1) Créé une copie du programme SetPatch dans RAM: en utilisant les 2 commandes Entrées/Sorties de données brutes ReadMem() et @{"WriteMem()" LINK WriteMem}. @ENDNODE @NODE WriteMem "Guide Hollywood" @{b}NOM@{ub} WriteMem -- sauver des données brutes dans un fichier (V2.0) @{b}SYNOPSIS@{ub} WriteMem(file_id, blk_id, len[, offset]) @{b}FONCTION@{ub} Cette commande sauvegarde @{b}len@{ub} octets d'un bloc mémoire spécifié par @{b}blk_id@{ub} au fichier spécifié par @{b}file_id@{ub}. Les données sont lues depuis le bloc mémoire à la position @{b}offset@{ub} (décalage). Les données sont sauvegardées dans un fichier depuis la position du curseur que vous pouvez modifier en utilisant la commande @{"Seek()" LINK Seek}. @{b}INPUTS@{ub} file_id - identificateur d'un fichier ouvert (utiliser @{"OpenFile()" LINK OpenFile}) blk_id - identificateur d'un bloc mémoire len - octets à sauvegarder dans un fichier offset - optionnel: où commencer à lire les données dans le bloc mémoire (défauts à 0 = début du bloc) @{b}EXEMPLE@{ub} voir @{"ReadMem" LINK ReadMem} @ENDNODE @NODE GetType "Guide Hollywood" @{b}NOM@{ub} GetType -- identifier une variable (V2.0) @{b}SYNOPSIS@{ub} type = GetType(var) @{b}FONCTION@{ub} Cette commande peut être utilisé pour identifier le type d'une variable ou d'une valeur. Les valeurs de renvoi possibles sont #NUMBER, #STRING ainsi que #TABLE, #FUNCTION, #USERDATA, #LIGHTUSERDATA, #THREAD et #NIL. Note importante: GetType() est la seule technique fiable pour découvrir si une variable est @{"Nil" LINK V6PrgTypeNil} ou non. Identifier la variable avec un identificateur Nil n'est pas conseillé parce que cela donnerait également comme résultat TRUE si la variable valait zéro au lieu de Nil. Exemple: a = 0 b = Nil DebugPrint(GetType(a) = #NIL, a = Nil) ; affiche "0 1" DebugPrint(GetType(b) = #NIL, b = Nil) ; affiche "1 1" Vous voyez que "a = Nil" retourne TRUE bien qu'il soit à zéro. C'est parce que Nil est toujours considéré comme zéro une fois utilisé dans les expressions. Ainsi, si vous voulez découvrir si une variable est réellement Nil, utiliser GetType() et comparer le résultat avec #NIL. Voir le chapitre @{"types de données" LINK V6PrgTypeIntro} pour plus d'information. @{b}INPUTS@{ub} var - variable à examiner @{b}EXEMPLE@{ub} type = GetType("Hello World") Ceci retournera #STRING. ------------------------ type = GetType({1, 2, 3, 4}) Ceci retournera #TABLE. ------------------------ type = GetType(Function() DebugPrint("Hello") EndFunction) Ceci retournera #FUNCTION. etc. @ENDNODE @NODE End "Guide Hollywood" @{b}NOM@{ub} End -- stopper Hollywood @{b}SYNOPSIS@{ub} End() @{b}FONCTION@{ub} Cette commande stoppera immédiatement votre script, arrêtera Hollywood et libèrera toute la mémoire et fermera toutes les bibliothèques. @{b}INPUTS@{ub} aucun @{b}RESULTATS@{ub} Un système Amiga irremplaçable qui continue à fonctionner. @ENDNODE @NODE Wait "Guide Hollywood" @{b}NOM@{ub} Wait -- attendre un temps spécifié @{b}SYNOPSIS@{ub} Wait(time[,unit]) @{b}FONCTION@{ub} Cette commande attend le temps spécifié par time et continue l'exécution du script. L'unité par défaut pour le temps est le tick. Un tick est égale à 1/50 seconde. Ainsi si vous voulez attendre une seconde, vous devrez régler time à 50. Depuis Hollywood 1.9 vous pouvez spécifier différentes unités afin de rendre l'attente plus précise. Les types suivants d'unités sont possibles : #MILLISECONDS : le temps en millisecondes (1/1000 seconde) #SECONDS : le temps en secondes #TICKS : le temps est en tick (défaut) (1/50 seconde) @{b}INPUTS@{ub} time - temps d'attente unit - optionnel: spécifier une unité de temps différente comme indiqué ci-dessus (défauts à #TICKS) (V1.9) @{b}EXEMPLE@{ub} Wait(200) Attente de 4 secondes. @ENDNODE @NODE SetVarType "Guide Hollywood" @{b}NOM@{ub} SetVarType -- déclarer une variable (obs.) @{b}SYNOPSIS@{ub} SetVarType(var,type[,arraysize]) @{b}FONCTION@{ub} Depuis Hollywood 2.0, cette commande est OBSOLETE et seulement disponible pour des raisons de compatibilité. Cette commande peut être utilisé pour déclarer une variable. Vous pouvez seulement l'utiliser pour déclarer les variables qui sont différentes du type par défaut(#LONG) et qui n'ont pas un identificateur dans leur nom comme le "$" pour des chaînes ou "!" pour des nombre à virgule flottante. Le tableau doit toujours être déclarés en spécifiant l'argument optionnel arraysize. @{b}INPUTS@{ub} var - nom de la variable à déclarer type - type désiré (peut être #LONG, #FLOAT, #STRING) arraysize - optionnel: si vous utilisez cet argument, un tableau de la taille spécifié sera alloué au lieu d'une seule variable @ENDNODE @NODE SetFPSLimit "Guide Hollywood" @{b}NOM@{ub} SetFPSLimit -- limiter les images par seconde (V1.5) @{b}SYNOPSIS@{ub} SetFPSLimit(fps) @{b}FONCTION@{ub} Cette commande limite le nombre d'images par seconde de certaines commandes Hollywood qui appellent @{"VWait()" LINK VWait}. Ces commandes sont : @{"PlayAnim()" LINK PlayAnim}, @{"MoveBrush()" LINK MoveBrush} etc., @{"DisplayTransitionFX()" LINK DisplayTransitionFX} etc., et @{"Flip()" LINK Flip}. Dans des conditions normales il n'est pas nécessaire d'utiliser cette commande puisque Hollywood limite automatiquement la vitesse d'affichage en interne. Par défaut, les commandes indiqué avant n'afficherons jamais plus d'images par seconde que se que l'écran peut régénèré. Vous pouvez désactiver ce type de fonctionnement avec cette commande mais se n'est pas conseillé (à moins que vous savez ce que vous faites). La meilleure solution est d'utiliser le synchroniseur vidéo d'Hollywood par défaut qui devrait afficher les animations les plus fluides possible. Utiliser cette commande avec précaution ou encore mieux, pas du tout. Si vous indiquez 0 pour fps, le synchroniseur vidéo par défaut sera restauré. @{b}INPUTS@{ub} fps - nombre maximum d'images par seconde défini ou 0 pour activer le synchroniseur vidéo d'Hollywood par défaut @ENDNODE @NODE GetFPSLimit "Guide Hollywood" @{b}NOM@{ub} GetFPSLimit -- obtenir le nombre limite d'images par seconde (V1.5) @{b}SYNOPSIS@{ub} fps = GetFPSLimit() @{b}FONCTION@{ub} Cette commande retourne la limite de fps défini par @{"SetFPSLimit()" LINK SetFPSLimit}. Si SetFPSLimit() n'est pas en fonctionnement, 0 sera retourné. Utiliser cette commande avec soin et @{"lire les précautions d'usages" LINK SetFPSLimit}. @{b}INPUTS@{ub} aucun @{b}RESULTATS@{ub} fps - limite du FPS ou 0 @ENDNODE @NODE IIf "Guide Hollywood" @{b}NOM@{ub} IIf -- retourner une valeur qui dépend d'une condition (V2.0) @{b}SYNOPSIS@{ub} ret = IIf(expr, true_expr, false_expr) @{b}FONCTION@{ub} Cette commande contrôle si l'expression spécifié est égale à TRUE (différent de zéro). Si elle l'est, la fonction retourne l'expression spécifié dans true_expr, sinon false_expr sera retourné. Il est important de noter que les deux expressions TRUE et FALSE sont évaluées dans tous les cas, aucun problème si l'expression est TRUE ou FALSE. Quelque chose qui ressemblerait à IIf(a <> 0, 5 / a, 0) ne peut pas fonctionner pour a=0 parce que Hollywood essayera d'évaluer 5/0 qui évidemment ne fonctionne pas. @{b}INPUTS@{ub} expr - expression source true_expr - expression à retourner si expr est TRUE false_expr - expression à retourner si expr est FALSE @{b}RESULTATS@{ub} ret - résultat @ENDNODE @NODE SystemRequest "Guide Hollywood" @{b}NOM@{ub} SystemRequest -- afficher une requête intuition @{b}SYNOPSIS@{ub} selection = SystemRequest(title$, body$, gadgets$[, icon]) @{b}FONCTION@{ub} Cette commande affiche une requête standard intuition qui affiche le message (body$) et permet également à l'utilisateur de faire une sélection en utilisant un des gadgets spécifié par gadgets$. Séparer les gadgets par un " | ". La valeur retournée indique quel gadget l'utilisateur a actionné. Veuillez noter que le gadget le plus à droite a toujours la valeur FALSE (0) parce qu'il est utilisé comme le gadget "Cancel". Si vous avez par exemple trois choix de gadget "Un|Deux|Trois ", le gadget "Trois" à la valeur de renvoi 0, " deux " renvois 2, et " Un " retourne 1. Vous pouvez également spécifier des codes d'échappement ici. Voir le chapitre @{"type de donnée chaîne" LINK V6PrgTypeString} pour plus d'information. Depuis Hollywood 4.0 : Vous pouvez utiliser l'argument optionnel icon afin d'ajouter un petit icône à la requête. Les icônes suivants sont possibles : #REQICON_NONE : aucun icône #REQICON_INFORMATION : un icône d'information #REQICON_ERROR : un icône d'erreur #REQICON_WARNING : un icône d'alarme #REQICON_QUESTION : un icône point d'interrogation Veuillez noter qu'actuellement les icônes de requête ne sont pas disponible sur chaque plate-forme. @{b}INPUTS@{ub} title$ - titre pour la requête; utiliser une chaîne vide ("") pour utiliser le titre par défaut body$ - texte à afficher dans le corps de la requête gadgets$ - un ou plusieurs gadget que l'utilisateur peut actionner icon - optionnel: icône à afficher dans la requête (par défauts: #REQICON_NONE) (V4.0) @{b}RESULTATS@{ub} selection - le gadget qui a été actionné par l'utilisateur @{b}EXEMPLE@{ub} sel=SystemRequest("Pizza Service","Sélectionner votre pizza!","Prosciutto e funghi|Calzone|Margerita|Hawaii") Switch sel Case 1: Print("1x Prosciutto e funghi = 8 Euro") Case 2: Print("1x Calzone = 10 Euro") Case 3: Print("1x Margerita = 9 Euro") Case 0: Print("1x Hawaii = 12 Euro") EndSwitch Le code ci-dessus demande à l'utilisateur une pizza et affiche le prix de cette pizza. @ENDNODE @NODE StringRequest "Guide Hollywood" @{b}NOM@{ub} StringRequest -- demander à l'utilisateur d'entrer dans une chaîne (V2.0) @{b}SYNOPSIS@{ub} s$ = StringRequest(title$, body$[, def$, type, maxchars, password]) @{b}FONCTION@{ub} Cette commande affiche une requête demandant à l'utilisateur d'entrer une chaîne. La fenêtre de requête aura le titre que vous spécifiez dans l'argument title$ et le texte de corps spécifié dans body$. Eventuellement, vous pouvez spécifier une chaîne par défaut qui sera affichée dans la bulle d'information. Si vous ne spécifiez pas def$, la bulle d'information sera vide. L'argument optionnel type peut être utilisé pour spécifier quels caractères l'utilisateur est autoriser à saisir, #ALL et #NUMERICAL sont actuellement compatible ici. L'argument optionnels maxchars peut être utilisé pour limiter le nombre de caractères que l'utilisateur peut taper. Cet argument est à 0 par défaut ce qui signifie que l'utilisateur peut taper autant de fois qu'il le veut. Le dernier mais pas le moins important est l'argument optionnel password, qui peut être réglé soit sur TRUE ou FALSE. S'il est réglé sur TRUE, les caractères que l'utilisateur tapera avec son clavier ne seront pas visibles à l'écran. La chaîne que l'utilisateur aura tapé sera retournée par cette commande. Si l'utilisateur annule cette requête, une chaîne vide sera retournée. Noter que cette commande exige que la reqtools.library soit installé sur AmigaOS 3, MorphOS, et AROS. Sous AmigaOS 4, la commande StringRequest() fonctionne sans la reqtools.library. @{b}INPUTS@{ub} title$ - titre pour la fenêtre de requête body$ - texte pour le corps de la requête def$ - optionnel: chaîne par défaut pour la bulle d'information (défauts a "") type - optionnel: quels caractères seront reçus par la requête; Les types actuellement possible sont #ALL (recevoir tout) et et #NUMERICAL (reçoit seulement des nombres) (défauts : #ALL) maxchars - optionnel: combien de caractères peuvent être saisis (défauts à 0, se qui signifie que l'utilisateur peut taper autant de fois qu'il le désire) password - optionnel: TRUE si les caractères ne doivent pas être visibles ou FALSE s'ils doivent être visibles (défauts à FALSE) @{b}EXEMPLE@{ub} a$ = StringRequest("Mon Programme", "Entrez votre nom!") Print("Hello,", a$, "!") Demander à l'utilisateur son nom et l'afficher. @ENDNODE @NODE FileRequest "Guide Hollywood" @{b}NOM@{ub} FileRequest -- afficher une requête de fichier @{b}SYNOPSIS@{ub} f$ = FileRequest (title$, pattern$ [, mode, defdir$, deffile$]) @{b}FONCTION@{ub} Cette commande affiche une requête de fichier qui permet à l'utilisateur de sélectionner un fichier. Vous pouvez spécifier le titre de la requête en en définissant l'argument title$. L'argument pattern$ vous permet de spécifier la configuration du filtre. Seul les fichiers qui s'apparenteront à se filtre seront sélectionnables dans la requête. La configuration du filtre est une chaîne qui contient un certain nombre de terminaison de fichier qui seront reçues par la requête. Ces terminaisons doivent être séparé par la caractère "|". Par exemple les terminaisons de fichier "mp3|wav|8svx|16sv|IFF|AIFF" seront seulement visible. Si vous ne voulez pas utiliser le filtre, utilisé "" ou "*" dans pattern$. Le fichier que l'utilisateur a sélectionné sera retourné dans f$, il sera inclus le chemin où il est enregistré. Si l'utilisateur annule la requête, la chaîne f$ sera vide. Nouveau dans la v2.0 : L'argument optionnel mode vous permet de mettre la la requête en mode sauvegarde ou multi-sélection. Pour le mode sauvegarde, définir #REQ_SAVEMODE et pour le mode multi-sélection #REQ_MULTISELECT. Si vous utilisez le mode mutli-sélection, cette commande ne retournera pas une chaîne mais un tableau qui contient tous les fichiers que l'utilisateur aura sélectionné terminé par une chaîne vide. Nouveau dans la v3.0 : Les deux arguments optionnels defdir$ et deffile$ vous permettent de spécifier un répertoire initial et lister quand la requête s'ouvre. Par défaut, se sera le répertoire courant sans le fichier actuellement sélectionné. @{b}INPUTS@{ub} title$ - titre pour la requête; définissez une chaîne vide ("") pour utiliser le titre par défaut pattern$ - configuration à utiliser; définissez une chaîne vide ("") pour avoir tous les fichiers affichés mode - optionnel: mode à utiliser; ou #REQ_NORMAL, #REQ_SAVEMODE ou #REQ_MULTISELECT (défauts : #REQ_NORMAL) (V2.0) defdir$ - optionnel: répertoire initial pour la requête de fichier (défaut à "" qui signifie le répertoire courant) (V3.0) deffile$ - optionnel: fichier initial pour la requête de fichier (défauts à "" qui signifie aucun fichier) (V3.0) @{b}RESULTATS@{ub} f$ - la sélection de l'utilisateur ou une chaîne vide s'il a été annulé par la requête; si la requête était ouverte dans le mode multi-sélection, un tableau contenant tous les fichiers serait retourné @{b}EXEMPLE@{ub} f$ = FileRequest("Sélectionner une image","png|jpg|jpeg|iff|pcx|bmp") If f$ = "" Print("Requête annulé!") Else Print("Votre sélection:", f$) EndIf Demander à l'utilisateur de choisir un fichier et afficher son nom. -------------------------- files = FileRequest("Selectionner des fichiers", "*", #REQ_MULTISELECT) If files[0] = "" Print("Requête annulé!") Else NPrint("Chemin:", PathPart(files[0])) NPrint("Fichiers sélectionnés:", ListItems(files) - 1) While files[c] <> "" NPrint(FilePart(files[c])) c = c + 1 Wend EndIf Le code ci-dessus ouvre une requête multi-sélection et affiches tous les fichiers que l'utilisateur a sélectionnés. @ENDNODE @NODE PathRequest "Guide Hollywood" @{b}NOM@{ub} PathRequest -- afficher une requête de chemin (V2.0) @{b}SYNOPSIS@{ub} p$ = PathRequest(title$[, mode, defdir$]) @{b}FONCTION@{ub} Cette fonction affiche une requête de chemin qui permet à l'utilisateur de sélectionner un chemin. Vous pouvez spécifier le titre de la requête en définissant l'argument title$. L'argument optionnel mode vous permet de mettre la requête dans le mode sauvegarde si vous spécifiez #REQ_SAVEMODE ici. Cette commande retourne la sélection du chemin de l'utilisateur ou "" si l'utilisateur a annulé la requête. Nouveau dans v3.0 : L'argument optionnel defdir$ vous permet de spécifier le répertoire initial quand la requête s'ouvre. Par défaut, ce sera le répertoire courant. @{b}INPUTS@{ub} title$ - titre pour la requête; définissez une chaîne ("") pour uiliser le titre par défaut mode - optionnel: #REQ_NORMAL pour le mode normal, #REQ_SAVEMODE pour le mode sauvegarde (défauts à #REQ_NORMAL) defdir$ - optionnel: répertoire initial pour la requête de fichier (défauts à "" qui signifie le répertoire courant) (V3.0) @{b}RESULTATS@{ub} p$ - la sélection de l'utilisateur ou une chaîne vide si il a annulé la requête @{b}EXEMPLE@{ub} p$ = PathRequest("Sélectionner un chemin") If(p$ = "") Print("Requête annulé!") Else Print("Votre sélection: ") Print(p$) EndIf Demander à l'utilisateur un chemin et afficher son nom. @ENDNODE @NODE WaitTimer "Guide Hollywood" @{b}NOM@{ub} WaitTimer -- attendre jusqu'à ce qu'un chronomètre ait atteint un certain temps (V2.0) @{b}SYNOPSIS@{ub} WaitTimer(id, time[, reset]) @{b}FONCTION@{ub} Cette commande arrête l'exécution jusqu'à ce que le chronomètre spécifié par id ait atteint le temps spécifié par time. Se temps est spécifiée en millisecondes. Avant que cette fonction effectue un retour il remettra à l'état initial le chronomètre spécifié de sorte que vous pourrez facilement utiliser cette commande dans une boucle. Vous pouvez changer ce type de fonctionnement en réglant l'argument optionnel reset à FALSE. Dans ce cas, le chronomètre ne sera pas remis à son état initial. WaitTimer() est extrêmement utile si vous voulez limiter la vitesse de certaines boucles. Par exemple, si vous avez une boucle qui déplace un sprite de gauche à droite, vous devriez ajouter un certain type de limitation de sorte qu'elle ne fonctionne pas plus rapidement que se qu'elle devrait. C'est très important. Même si le script fonctionne à la bonne vitesse sans WaitTimer(), vous ne devrez pas oublier qu'il y a des machines plus rapides que la vôtre. Utiliser WaitTimer() dans vos boucles, permettra que votre application fonctionne sur tous les systèmes à la même vitesse. Voir également le chapitre @{"timing du script" LINK V6PrgG2KTiming} pour plus d'information. @{b}INPUTS@{ub} id - identification du chronomètre à questionner time - temps en millisecondes que le chronomètre doit avoir reset - optionnel: spécifie si ou non le chronomètre sera remis à l'état initial après que WaitTimer() effectue un retour (défauts à TRUE qui signifie que le chronomètre sera remis à son état initial) @{b}EXEMPLE@{ub} StartTimer(1) For k = 0 To 640 DisplaySprite(1, k, 0) WaitTimer(1, 40) Next Le code ci-dessus déplace le sprite 1 de gauche à droite. Après chaque appel à DisplaySprite(), WaitTimer() est utilisé pour s'assurer que nous attendons au moins 40 millisecondes jusqu'au prochain DisplaySprite(). Ainsi, cette boucle ne sera pas accompli plus de 25 fois par seconde parce que 40 * 25 = 1000. @ENDNODE @NODE Error "Guide Hollywood" @{b}NOM@{ub} Error -- quitter avec un message d'erreur personnifié (V2.0) @{b}SYNOPSIS@{ub} Error(msg$) @{b}FONCTION@{ub} Cette commande stoppe le script et affiche un message spécifié dans msg$. C'est utile si votre script est interrompue parce qu'une condition inattendue s'est produite. @{b}INPUTS@{ub} msg$ - message d'erreur à afficher @{b}RESULTATS@{ub} (Cette fonction ne retourne rien) @{b}EXEMPLE@{ub} If Exists("Game.dat") = False Then Error("Impossible de lire les données du jeu!") Le code ci-dessus vérifie si le fichier "Game.dat" existe et quitte avec un message d'erreur si il n'existe pas. @ENDNODE @NODE NextItem "Guide Hollywood" @{b}NOM@{ub} NextItem -- passer à l'item suivant dans un tableau (V2.0) @{b}SYNOPSIS@{ub} next, item = NextItem(table[, start]) @{b}FONCTION@{ub} Cette commande vous permet de passer tous les items du tableau spécifié par l'argument table. Pour effectuer ceci, vous devez définir le tableau dans l'argument table et ignorer le deuxième argument. NextItem() retourne alors l'adresse de la prochaine valeur et la première valeur dans le tableau. Pour passer tous les items, vous devez définir la "prochaine" valeur à NextItem() comme seconde argument et de déclarer une boucle jusqu'à se que la "prochaine" valeur soit @{"Nil" LINK V6PrgTypeNil}. Quand il n'y a plus d'item dans le tableau, @{"Nil" LINK V6PrgTypeNil} est retourné et vous pouvez fin à votre boucle. Attention en vérifiant des variables qui sont Nil puisque 0=Nil est pour le moment vrai dans Hollywood. @{"GetType()" LINK GetType} est la seul méthode fiable pour découvrir si une variable est réellement Nil. En vérifiant simplement qu'elle est Nil, il pourrait également y avoir comme résultat TRUE si la variable était égale à 0. Ne pas s'attendre à ce que cette commande retourne les adresses de tableau dans l'ordre qu'elles ont été affectés. Hollywood les enregistres souvent dans des ordres différents. @{b}INPUTS@{ub} table - tableau à traverser start - optionnel: où commencer la traverser (défauts à Nil qui commence au début) @{b}RESULTATS@{ub} next - index du prochains item du tableau ou Nil s'il n'y a plus d'items item - valeur de tableau à l'index "start" @{b}EXEMPLE@{ub} t = {1, 2, 3, 4, 5, "Hello World", {100, 200, 300}, [-1.5] = -1.5, b = 66, Function DebugPrint EndFunction} a, b = NextItem(t) While GetType(a) <> #NIL DebugPrint(b) a, b = NextItem(t, a) Wend Le code ci-dessus traverse un tableau hétérogène. La sortie sera la suivante: 2 3 4 5 Hello World Table: 74cbd42c Function: 74cbd3c8 1 -1.5 66 Vous voyez que les items sont retournés dans un ordre différent. @ENDNODE @NODE GetVersion "Guide Hollywood" @{b}NOM@{ub} GetVersion -- obtenir les informations sur la version de Hollywood utilisé (V3.0) @{b}SYNOPSIS@{ub} t = GetVersion() @{b}FONCTION@{ub} Cette commande peut être utilisé pour obtenir quelques informations sur la version d'Hollywood faisant fonctionner actuellement votre script ou applet. Vous pouvez également rechercher l'informations sur la plate-forme qui fait fonctionner votre script. Cette commande renverra un tableau avec les indicateurs suivants initialisés: Application : Ce sera "Hollywood" ou "HollywoodPlayer", cela dépend sous quelle version il est exécuté. Si vous sauvegardez votre script comme un exécutable, ceci sera toujours "HollywoodPlayer". Version : Une chaîne contenant la version d'Hollywood, par exemple "3.0". Version_Date : Une chaîne contenant la date de compilation de la version d'Hollywood Kernel : Une chaîne contenant la version du noyau Hollywood, par exemple "3.0". Kernel_Date : Une chaîne contenant la date de compilation du kernel d'Hollywood Beta : Cet indicateur sera réglé sur TRUE si une version bêta d'Hollywood est utilisé, sinon FALSE. Platform : C'est probablement l'indicateur le plus utile puisqu'il contient la plate-forme sur laquelle Hollywood fonctionne actuellement. Cet indicateur peut être "AmigaOS3", "MorphOS", "WarpOS", ou "AmigaOS4", "AROS", "Win32", "MacOS". @{b}INPUTS@{ub} aucun @{b}RESULTATS@{ub} t - un tableau contenant des informations sur la version de Hollywood en utilisation @{b}EXEMPLE@{ub} t = GetVersion() If t.platform = "Win32" Then Error("Désolé, Win32 n'est pas supporté!") Le code ci-dessus vérifie sur quelle version nous fonctionnons et quitte avec une erreur si Hollywood fonctionne sur Win32. @ENDNODE @NODE GetCommandLine "Guide Hollywood" @{b}NOM@{ub} GetCommandLine -- obtenir les arguments de la ligne de commande (V3.0) @{b}SYNOPSIS@{ub} t, n = GetCommandLine() @{b}FONCTION@{ub} Cette commande vous permet d'obtenir les arguments que votre script à besoin quand il est exécuter. Ceci permet à votre script d'utiliser des arguments que l'utilisateur peut définir et réagi alors en conséquent. Tous les arguments qui ne sont pas identifiés par Hollywood seront envoyé à votre script. Veuillez noter que les arguments doivent être préfixés par un caractère tiret (-). Un paramètre peut également suivre après chaque argument. GetCommandLine() retourne deux valeurs: La deuxième valeur de renvoi est un nombre qui spécifie simplement combien d'arguments ont été réussis à la ligne de commande de votre script. La première valeur de renvoi est un tableau qui contient tous les arguments et leurs paramètres. Le tableau est un tableau de "n" - tableau avec les items "arg" et "param". "arg" sera initialisé à l'argument à l'exclusion du caractère tiret . "param" recevra le paramètre pour cet argument si il y en a un, sinon il recevra une chaîne vide (""). Sous AmigaOS cette commande prendra en compte également les tooltypes du script ou d'icône d'applet si le programme était exécuté à partir du WorkBench. Sous Mac OS, cette commande examinera l'entrée du dictionnaire dans le "CFBundleExecutableArgs" dans le paquet d'application Info.plist si le programme a été exévuté à partir de Finder. @{b}INPUTS@{ub} aucun @{b}RESULTATS@{ub} t - tableau contenant tous les arguments et leurs paramètres n - nombre d'arguments qui ont été réussis au programme @{b}EXEMPLE@{ub} args, count = GetCommandLine() NPrint("Nombre d'arguments:", count) For Local k = 0 to count - 1 NPrint("Arg #", k, ":", args[k].arg, "Param:", args[k].param) Next Le code ci-dessus obtient tous les arguments de la ligne de commande et les affiches à l'écran. @ENDNODE @NODE GetProgramInfo "Guide Hollywood" @{b}NOM@{ub} GetProgramInfo -- obtenir les informations sur le programme en cours (V3.0) @{b}SYNOPSIS@{ub} type, name$[, hw$] = GetProgramInfo() @{b}FONCTION@{ub} Cette commande peut être utilisé pour obtenir quelques informations sur le programme Hollywood actuellement exécuté. GetProgramInfo() renverra deux valeurs: la première valeur de renvoi spécifie le type de programme fonctionnant actuellement avec Hollywood. Cette variable peut être #PRGTYPE_SCRIPT pour des script Hollywood, ou #PRGTYPE_APPLET pour des applet Hollywood, ou #PRGTYPE_PROGRAM pour des exécutables. La deuxième valeur de renvoi est une chaîne qui contient le nom du fichier du programme actuellement exécuté. Si le programme lancé est un applet ou un script, son nom sera retournée dans name$. Si le programme lancé est un exécutable compilé, name$ recevra le nom de fichier de cet exécutable. Si le programme lancé est un applet ou un script, il y aura une troisième valeur hw$. Cette valeur de renvoi contiendra le nom du fichier de l'interpréteur Hollywood utilisé pour faire fonctionner cet applet ou script. @{b}INPUTS@{ub} aucun @{b}RESULTATS@{ub} type - type du programme lancé (#PRGTYPE_SCRIPT, #PRGTYPE_APPLET ou #PRGTYPE_PROGRAM) name$ - nom de fichier du programme lancé hw$ - optionnel: cette valeur est seulement retournée si le programme lancé est un script ou un applet; il spécifie le chemin de l'interpréteur Hollywood utilisé pour faire fonctionner ce script ou applet @ENDNODE @NODE CreatePointer "Guide Hollywood" @{b}NOM@{ub} CreatePointer -- créer un nouveau pointeur de souris (V4.0) @{b}SYNOPSIS@{ub} [id] = CreatePointer(id, type, ...) [id] = CreatePointer(id, #SPRITE, srcid[, frame, spotx, spoty]) [id] = CreatePointer(id, #BRUSH, srcid[, spotx, spoty]) [id] = CreatePointer(id, #POINTER, ptrtype) @{b}FONCTION@{ub} Cette commande créée un nouveau pointeur de souris et lui affecte l'identification id. Si vous indiquez @{"Nil" LINK V6PrgTypeNil} comme identification, CreatePointer() choisira automatiquement une identification vide et la retournera. L'objet de pointeur de souris créé par cette commande peut être affiché plus tard en utilisant la commande @{"SetPointer()" LINK SetPointer}. Les pointeurs de souris peuvent être créées à partir d'un sprite ou d'une brosse, ou vous pouvez choisir un pointeur de souris prédéfini. La méthode d'exécution de CreatePointer() dépend du type que vous spécifiez comme deuxième argument. Pour les types #SPRITE et #BRUSH vous devez spécifier l'identification de l'objet qui sera utilisé comme source pour les dessins du pointeur. Le pointeur de souris créé par cette commande est indépendant de l'objet source ainsi vous pouvez libérer l'objet source après avoir appelé CreatePointer(). Si vous spécifiez #POINTER comme type, vous devez fournir un argument supplémentaire qui définit qu'elle image de pointeur de la souris prédéfinie vous voulez obtenir. Actuellement, ceci peut être #STDPTR_SYSTEM pour le pointeur système standard et #STDPTR_BUSY pour le pointeur d'attente du système standard. Les arguments spotx et spoty spécifient le point de contact à l'intérieur du pointeur de souris. Le point de contact est le pixel du pointeur de la souris qui est utilisé pour cliqueter. Si l'image du pointeur de la souris est une flèche, alors le point de contact est habituellement à la pointe de la flèche. Si vous ne spécifiez pas les arguments spotx et spoty, CreatePointer() utilisera le centre de l'image en tant que point de contact. Noter que certains systèmes ne peuvent pas traiter les vraies couleurs du pointeur de souris. Si le système ne supporte pas les véritables couleurs du pointeur de souris, Hollywood Réduira le nombre de ces couleurs. En outre, vos caractéristiques d'image pourraient être redimensionné puisque quelques systèmes imposent des limites sur la taille maximum du pointeur de souris. @{b}INPUTS@{ub} id - identification pour le pointeur de souris ou @{"Nil" LINK V6PrgTypeNil} pour la @{"sélection automatique d'id" LINK AutoIDSelect} type - type de donnée source .. - autres arguments qui dépendent du type spécifié (voir ci-dessus) @{b}RESULTATS@{ub} id - optionnel: identificateur du pointeur de la souris; sera seulement retourné quand vous obtenez @{"Nil" LINK V6PrgTypeNil} comme argument 1 (voir ci-dessus) @{b}EXEMPLE@{ub} CreatePointer(1, #BRUSH, 2, 0, 0) SetPointer(1) Le code ci-dessus créé un nouveau pointeur de souris 1 avec la brosse avec l'identification 2. Le point de contact sera à la position 0:0 (c.-à-d. le coin en haut à gauche de l'image). Après avoir créé le pointeur de souris elle sera affichés en utilisant SetPointer(). @ENDNODE @NODE FreePointer "Guide Hollywood" @{b}NOM@{ub} FreePointer -- libérer un pointeur de souris (V4.0) @{b}SYNOPSIS@{ub} FreePointer(id) @{b}FONCTION@{ub} Cette commande libère le pointeur de souris spécifié par id. Le pointeur de la souris doit avoir été créé précédemment en utilisant @{"CreatePointer()" LINK CreatePointer}. Noter que le pointeur de souris ne doit pas être actif. Vous pouvez seulement libérer le pointeur de souris que si il n'est pas affiché. @{b}INPUTS@{ub} id - identification du pointeur de souris à libérer @ENDNODE @NODE V6LibSysDate "Guide Hollywood" @{b}Fonction Date et heure@{ub} @{"GetDate() " LINK GetDate} renvoyer une chaîne de caractères contenant la date @{"GetDateNum() " LINK GetDateNum} obtenir l'information de la date @{"GetTime() " LINK GetTime} obtenir l'heure en cours @{"GetWeekday() " LINK GetWeekday} obtenir le jour de la semaine @ENDNODE @NODE V6LibSysLocale "Guide Hollywood" @{b}Fonction Locale@{ub} @{"CloseCatalog() " LINK CloseCatalog} fermer un catalogue ouvert @{"GetCatalogString() " LINK GetCatalogString} obtenir une chaîne d'un catalogue @{"OpenCatalog() " LINK OpenCatalog} ouvrir un catalogue @ENDNODE @NODE V6LibSysReq "Guide Hollywood" @{b}Fonction requête@{ub} @{"FileRequest() " LINK FileRequest } afficher une requête de fichier @{"PathRequest() " LINK PathRequest } afficher une requête de chemin (V2.0) @{"StringRequest() " LINK StringRequest} demander à l'utilisateur d'entrer dans une chaîne (V2.0) @{"SystemRequest() " LINK SystemRequest} afficher une requête intuition @ENDNODE @NODE V6LibSysDebug "Guide Hollywood" @{b}Fonction de débugage@{ub} @{"DebugOutput() " LINK DebugOutput } activer/désactiver la sortie de débuggage @{"DebugPrint() " LINK DebugPrint } afficher l'information de débogage (V2.0) @{"DebugStr() " LINK DebugPrint } afficher une chaîne de débogage @{b}OBSOLETE@{ub} @{"DebugVal() " LINK DebugPrint } afficher une valuer de débogage @{b}OBSOLETE@{ub} @{"Error() " LINK Error } quitter avec un message d'erreur personnifié (V2.0) @{"ExitOnError() " LINK ExitOnError } activer/désactiver le gestionnaire automatique d'erreurs @{"GetErrorName() " LINK GetErrorName} obtenir la chaîne définissant le code d'erreur @{"GetLastError() " LINK GetLastError} obtenir Le code erreur de la dernière commande @ENDNODE @NODE V6LibSysList "Guide Hollywood" @{b}Fonction liste@{ub} @{"InsertItem() " LINK InsertItem} insérer un item dans une liste (V2.0) @{"ListItems() " LINK ListItems } compter le nombre d'item d'une liste (V2.0) @{"NextItem() " LINK NextItem } passer à l'item suivant dans un tableau (V2.0) @{"RemoveItem() " LINK RemoveItem} retirer un item d'une liste (V2.0) @{"Unpack() " LINK Unpack } décompresser un tableau (V2.0) @ENDNODE @NODE V6LibSysPointer "Guide Hollywood" @{b}Fonction pointeur de souris@{ub} @{"CreatePointer() " LINK CreatePointer} créer un nouveau pointeur de souris (V4.0) @{"FreePointer() " LINK FreePointer } libérer un pointeur de souris (V4.0) @{"HidePointer() " LINK HidePointer } cacher le pointeur de souris @{"MovePointer() " LINK MovePointer } déplacer le pointeur de souris @{"SetPointer() " LINK SetPointer } installer un nouveau pointeur de souris (V1.5) @{"ShowPointer() " LINK ShowPointer } afficher le pointeur de souris @ENDNODE @NODE V6LibSysMemory "Guide Hollywood" @{b}Fonction bloc mémoire@{ub} @{"AllocMem() " LINK AllocMem} allouer une nouvelle place mémoire (V2.0) @{"CopyMem() " LINK CopyMem } copier les données entre des blocs mémoire (V2.0) @{"DumpMem() " LINK DumpMem } vider le contenu d'un bloc mémoire (V2.0) @{"FillMem() " LINK FillMem } remplir un bloc mémoire (V2.0) @{"FreeMem() " LINK FreeMem } libérer un espace mémoire (V2.0) @{"Peek() " LINK Peek } lire à l'intérieur d'un bloc mémoire (V2.0) @{"Poke() " LINK Poke } écrire dans un bloc mémoire (V2.0) @{"ReadMem() " LINK ReadMem } lire les données brutes à partir d'un fichier (V2.0) @{"WriteMem() " LINK WriteMem} sauver des données brutes dans un fichier (V2.0) @ENDNODE @NODE V6LibSysTimer "Guide Hollywood" @{b}Fonction mesure du temps@{ub} @{"GetTimer() " LINK GetTimer} obtenir le temps d'un chronomètre @{"PauseTimer() " LINK PauseTimer} effectuer une pause sur un chronomètre @{"ResumeTimer() " LINK ResumeTimer} reprendre un chronomètre qui est en pause @{"StartTimer() " LINK StartTimer} démarrer un nouveau chronomètre @{"StopTimer() " LINK StopTimer} arrêter un chronomètre @{"WaitTimer() " LINK WaitTimer} attendre jusqu'à ce qu'un chronomètre ait atteint un certain temps (V2.0) @ENDNODE @NODE V6LibSysMisc "Guide Hollywood" @{b}Fonction diverse@{ub} @{"End() " LINK End} stopper Hollywood @{"GetCommandLine() " LINK GetCommandLine} obtenir les arguments de la ligne de commande (V3.0) @{"GetMemoryInfo() " LINK GetMemoryInfo } obtenir des informations sur la mémoire @{"GetProgramInfo() " LINK GetProgramInfo} obtenir les informations sur le programme en cours (V3.0) @{"GetType() " LINK GetType } examiner une variable (V2.0) @{"GetVersion() " LINK GetVersion } obtenir les informations sur la version de Hollywood utilisé (V3.0) @{"IIf() " LINK IIf } retourner une valeur qui dépend d'une condition (V2.0) @{"SetFPSLimit() " LINK SetFPSLimit } limiter les images par seconde (V1.5) @{"SetVarType() " LINK SetVarType } déclarer une variable (obs.) @{"Sort() " LINK Sort } trier un tableau @{"Wait() " LINK Wait } attendre un temps spécifié @ENDNODE @NODE V6LibSys "Guide Hollywood" @{b}Bibliothèque SYSTEME@{ub} La bibliothèque système contient des fonctions utiles de différents types. Par exemple, les commandes qui demandent l'information sur le système de l'utilisateur et des options de réglage de langue. En outre elle fournit quelques autres commandes utiles comme le débugage de bas niveau, des commandes d'accès mémoire et des commandes de pointeur de souris. @{"Fonction Date et heure " LINK V6LibSysDate} Interroger la date système ou l'heure, etc... @{"Fonction mesure du temps " LINK V6LibSysTimer} Mesure du temp entre 2 temps @{"Fonction Locale " LINK V6LibSysLocale} Support de différent langage @{"Fonction de débugage " LINK V6LibSysDebug} Fonction de débugage de bas niveau @{"Fonction liste " LINK V6LibSysList} Les tableaux peuvent être utilisés comme des listes @{"Fonction pointeur de souris " LINK V6LibSysPointer} Installer un nouveau pointeur de souris @{"Fonction bloc mémoire " LINK V6LibSysMemory} Fonction de bas niveau sur les blocs mémoires @{"Fonction diverse " LINK V6LibSysMisc} D'autres fonctions système @ENDNODE @NODE GetVolumeInfo " Guide Hollywood " @{b}NOM@{ub} GetVolumeInfo -- obtenir les informations sur la capacité d'un volume @{b}SYNOPSIS@{ub} space=GetVolumeInfo (vol$,id) @{b}FONCTION@{ub} Cette commande interroge le volume spécifié par vol$ afin d'obtenir des informations sur le type d'espace spécifié par id. Les constantes suivantes sont possibles pour id: #FREESPACE : retourne l'espace libre du volume #USEDSPACE : retourne l'espace utilisé du volume @{b}INPUTS@{ub} vol$ - nom d'un volume DOS id - une des constantes comme indiquée ci-dessus @{b}RESULTATS@{ub} space - espace libre/utilisé du volume @{b}EXEMPLE@{ub} space=GetVolumeInfo ("SYS:", #FREESPACE) Print (space," octets libre sur SYS: !") Le code ci-dessus retourne l'espace libre du volume SYS: . @ENDNODE @NODE CloseFile " Guide Hollywood " @{b}NOM@{ub} CloseFile -- fermer un fichier ouvert @{b}SYNOPSIS@{ub} CloseFile (Id) @{b}FONCTION@{ub} Ferme le fichier @{b}id@{ub} qui a été ouvert avec la commande @{"OpenFile()" LINK OpenFile}. @{b}INPUTS@{ub} Id - numéro de fichier ouvert @{b}EXEMPLE@{ub} voir la commande @{"OpenFile()" LINK OpenFile} @ENDNODE @NODE DeleteFile "Guide Hollywood" @{b}NOM@{ub} DeleteFile -- effacer un fichier ou un répertoire @{b}SYNOPSIS@{ub} DeleteFile(file$[, callback, userdata]) @{b}FONCTION@{ub} Efface le fichier spécifié file$ de votre disque dur/RAM/disquette ou autre. Cette fonction ne retourne pas d'erreur si le fichier n'existe pas. Cette fonction est une extension à Hollywood 2.0. Les fonctionnalitées suivantes sont nouvelles : - Cette commande peut également effacer les répertoires entiers. Elle ne vérifie pas si le répertoire est vide ou pas. Si vous spécifiez un répertoire, il sera effacé ainsi que l'arborescence. Attention, à utilisé avec précaution. - Vous pouvez spécifier un chemin dans file$ et DeleteFile() effacera seulement les fichiers et les répertoires qui sont liés au chemin. - Vous pouvez spécifier une fonction de rappel (affiché ci-dessous) La fonction de rappel peut être spécifié dans l'argument 2 callback. DeleteFile() l'appellera de temps en temps, ainsi, par exemple, vous pouvez mettre à jour une barre de progression. De plus, si vous spécifiez une fonction de rappel, DeleteFile() vous demandera la confirmation de la déprotection des fichiers protégés contre l'effacement. Si il n'y a aucune fonction de rappel, DeleteFile() n'effacera pas les fichiers protégés. La fonction de rappel reçoit un argument : Un tableau qui contient des information. Les rappels suivants sont disponibles: Fonction de rappel #DELETEFILE_UNPROTECT: Action : #DELETEFILE_UNPROTECT fichier : Contient le fichier protégé a effacer qui sera déprotégé. (Le chemin complet) UserData : Contient la valeur que vous avez spécifiée dans l'argument userdata. La fonction de rappel du type #DELETEFILE_UNPROTECT sera appellé si le fichier qui doit être effacé est protégé contre l'effacement. Cette fonction de rappel doit retourner la valeur TRUE si la déprotection du fichier est validé ou FALSE si il ne doit pas être déprotégé. Si vous indiquez -1, la fonction d'effacement sera interrompu. * * * Fonction de rappel #DELETEFILE_STATUS: Action : #DELETEFILE_STATUS fichier : Contient le chemin complet du fichier qui doit être ensuite effacé UserData : Contient la valeur que vous avez spécifiée dans l'argument userdata. La fonction de rappel du type #DELETEFILE_STATUS devrait normalement retourner FALSE. S'il retourne TRUE, la fonction d'effacement sera interrompu. Depuis Hollywood 3.1 il y a un argument optionnel appelé "userdata". La valeur que vous spécifiez ici est transmis à votre fonction de rappel à chaque fois qu'elle s'exécute. C'est utile si vous voulez éviter de travailler avec des variables globales. Grce à l'argument "userdata" vous pouvez passer facilement des données à votre fonction de rappel. Vous pouvez spécifier une valeur de n'importe quel type dans "userdata". Nombres, chaînes de caractères, tableaux, et fonctions peuvent être utilisé comme données utilisateurs. @{b}INPUTS@{ub} file$ - Nom de fichier ou répertoire à effacer callback - optionnel: une fonction de rappels a utiliser depuis la V2.0 userdata - optionnel: données utilisateurs particulières à transmettre par l'intermédiaire de la fonction de rappels (V3.1) @{b}EXEMPLE@{ub} DeleteFile("dh0:FooBar") Efface le fichier " FooBar " de dh0 :. ------------------------------------------------------------ FONCTION p_DeleteCallback(msg) Switch msg.action Case #DELETEFILE_STAvousS: DebugPrint("Now deleting", FilePart(msg.file)) Case #DELETEFILE_UNPROTECT: Return(SystemRequest("Hollywood", FilePart(msg.file) .. " est protégé contre l'effacement!\\n" .. "Voulez-vous enlever cette protection?", "Yes|No")) EndSwitch Return(False) EndFunction DeleteFile("dh0:TestDir", p_DeleteCallback) Démonstration de l'utilisation d'une fonction de rappel. @ENDNODE @NODE EOF "Guide Hollywood" @{b}NOM@{ub} EOF -- retourner une valeur si la fin du fichier est atteinte @{b}SYNOPSIS@{ub} result=Eof (id) @{b}FONCTION@{ub} Renvoie TRUE si l'extrémité du fichier spécifié par id est atteinte. Sinon retourne FALSE. @{b}INPUTS@{ub} id - le numéro d'identification spécifiant un fichier ouvert @{b}RESULTATS@{ub} résultat - TRUE si la fin de fichier est atteint ou FALSE @{b}EXEMPLE@{ub} Voir la commande @{"OpenFile()" LINK OpenFile} @ENDNODE @NODE Exists " guide de Hollywood " @{b}NOM@{ub} Exists -- vérifier si le fichier spécifié existe @{b}SYNOPSIS@{ub} result=Exists (fileName$) @{b}FONCTION@{ub} Vérifie si le fichier spécifié par fileName$ existe et renvoie TRUE au résultat de la variable si le fichier est présent. Sinon le résultat reçoit la valeur FALSE. @{b}INPUTS@{ub} fileName$ - fichier à vérifier si il existe @{b}RESULTATS@{ub} résultat - TRUE si le fichier spécifié existe, sinon FALSE @{b}EXEMPLE@{ub} result=Exists("S:Startup-Sequence") Print(result) Ce code devrait toujours afficher " 1 " qui est la valeur de TRUE. @ENDNODE @NODE FileSize "Guide Hollywood" @{b}NOM@{ub} FileSize -- retourner la taille d'un fichier spécifié @{b}SYNOPSIS@{ub} size=FileSize (file$) @{b}FONCTION@{ub} Retourne la taille du fichier file$. Si le fichier n'existe pas, -1 est retourné. @{b}INPUTS@{ub} file$ - nom du fichier source @{b}RESULTATS@{ub} size- taille du fichier spécifié en octets @{b}EXEMPLE@{ub} result=FileSize("S:Startup-Sequence") Print("Your Startup-Sequence has", result, "bytes!") Ce code afficherà la taille en octet de votre Startup-Sequence. @ENDNODE @NODE OpenFile "Guide Hollywood" @{b}NOM@{ub} OpenFile -- ouvrir un fichier pour le lire et y écrire @{b}SYNOPSIS@{ub} [id] = OpenFile(id, fileName$[, mode]) @{b}FONCTION@{ub} Cette commande ouvre le fichier spécifié par fileName$ et lui affecte un identifiant id. Si vous indiquez @{"Nil" LINK V6PrgTypeNil} comme id, OpenFile() choisira automatiquement une id vide et la retournera. Si le fichier n'existe pas, cette commande ne retournera pas de message d'erreur à moins que vous utilisiez l'argument mode pour ouvrir un fichier en mode écriture. Dans ce cas, OpenFile() crééra le fichier. Toutes les opérations de lectures et d'écriture commenceront au fichier courant à la position du curseur. Vous pouvez sélectionner manuellement la position du curseur dans le fichier par l'utilisation de la commande @{"Seek()" LINK Seek} mais elle est également intéressante si vous utilisez d'autres commandes qui lisent ou écrivent dans le fichier. Depuis Hollywood 2.0 vous pouvez utiliser l'argument optionnel Mode pour ouvrir le fichier en mode lecture (par défaut), en mode écriture ou dans le mode partagé, le mode partagé signifie que vous pouvez lire à partir du fichier et également y écrire. Si un fichier est ouvert en mode lecture, toutes les opérations d'écriture ne fonctionneront pas. Si un fichier est ouverts en mode écriture, toutes les opérations de lecture ne fonctionneront pas. Bien que Hollywood ferme automatiquement tous les fichiers ouverts quand il est quitté, il est fortement conseiller que vous fermiez votre fichier quand vous avez fini vos opérations en utilisant la commande @{"CloseFile()" LINK CloseFile} de sorte qu'il soit de nouveau disponible pour le système d'exploitation. Cette commande est également disponible via une commande préprocesseur. Utilisez @{"@FILE" LINK atFILE} pour pré-ouvrir des fichiers ! @{b}INPUTS@{ub} Id - identité du fichier ou @{"Nil" LINK V6PrgTypeNil} pour @{"la sélection d'identification automatique" LINK AutoIDSelect} fileName$ - nom du fichier à ouvrir mode - mode d'ouverture du fichier; peut être #MODE_READ, #MODE_WRITE ou #MODE_READWRITE (par défauts : #MODE_READ) (V2.0) @{b}RESULTATS@{ub} id - optionnel: identificateur du fichier; sera seulement retourné quand vous obtenez @{"Nil" LINK V6PrgTypeNil} comme argument 1 (voir ci-dessus) @{b}EXEMPLE@{ub} OpenFile(1, "S:Startup-Sequence") While Not Eof(1) Do NPrint(ReadLine(1)) CloseFile (1) Ce code ouvre votre startup-sequence comme fichier 1 et affiche son contenu sur l'écran. @ENDNODE @NODE ReadChr "Guide Hollywood" @{b}NOM@{ub} ReadChr -- lire un caractère provenant d'un fichier spécifié @{b}SYNOPSIS@{ub} chr=ReadChr (id) @{b}FONCTION@{ub} Cette commande lit le prochain caractère à partir du fichier spécifié par id et retourne sa valeur ASCII. La position du curseur dans le fichier est incrémentée de 1. @{b}INPUTS@{ub} id - numéro spécifiant le fichier à lire @{b}RESULTATS@{ub} chr - prochain caractère du fichier @{b}EXEMPLE@{ub} OpenFile(1,"Ram:test") WriteLine(1,"Bonjour tous le monde! Comment allez-vous?") Seek(1,0) test=ReadChr(1) CloseFile(1) test$=Chr(test) Print(test$) Le code ci-dessus affichera " H " à l'écran. @ENDNODE @NODE ReadLine "Guide Hollywood" @{b}NOM@{ub} ReadLine -- lire une ligne du fichier spécifié @{b}SYNOPSIS@{ub} string$=ReadLine(id) @{b}FONCTION@{ub} Cette commande affiche les caractères à partir du fichier spécifié par id jusqu'à se qu'un retour à la ligne se produise. Ce retour à la ligne n'est pas compris dans la chaîne de retour. Cette commande s'arrête également quand il atteint la fin du fichier. La chaîne lu est retourné. @{b}INPUTS@{ub} id - numéro spécifiant un fichier ouvert @{b}RESULTATS@{ub} string$ - reçoit la ligne affichée @{b}EXEMPLE@{ub} voir la commande @{"OpenFile()" LINK OpenFile} @ENDNODE @NODE Seek "Guide Hollywood" @{b}NOM@{ub} Seek -- positionner le curseur du fichier sur une nouvelle position @{b}SYNOPSIS@{ub} Seek (id, newpos) @{b}FONCTION@{ub} Cette commande positionne le curseur du fichier (depuis toutes les opérations de lecture/écriture) à la nouvelle position (newpos). Le début du fichier est à la position 0. Si vous voulez déplacer le curseur à la fin du fichier, indiquer à newpos la constante spéciale #EOF. Pour découvrir la position de curseur d'un fichier spécifié, vous pouvez utiliser la commande @{"FilePos()" LINK FilePos}. @{b}INPUTS@{ub} id - numéro spécifiant le fichier à utiliser newpos - nouvelle position du curseur @{b}EXEMPLE@{ub} voir la commande @{"ReadChr()" LINK ReadChr} @ENDNODE @NODE WriteChr "Guide Hollywood" @{b}NOM@{ub} WriteChr -- écrire un caractère dans un fichier @{b}SYNOPSIS@{ub} WriteChr(id,chr) @{b}FONCTION@{ub} Ecrit le caractère décrit par chr dans le fichier ouvert définie par id et incrémente le curseur du fichier de 1. @{b}INPUTS@{ub} id - numéro spécifiant le fichier à utiliser chr - caractère à écrire dans le fichier @{b}EXEMPLE@{ub} OpenFile("Ram:Test") WriteChr(1, 65) CloseFile() Ce code écrira le caractère " A " dans le fichier RAM:Test. @ENDNODE @NODE WriteLine "Guide Hollywood" @{b}NOM@{ub} WriteLine -- écrire une nouvelle ligne dans un fichier @{b}SYNOPSIS@{ub} WriteLine(id,line$) @{b}FONCTION@{ub} Ecrit la chaîne de caractères spécifié par line$ dans le fichier définie par id et incrémente le curseur de la longueur de chaîne de caractères + 1 (retour à la ligne). @{b}INPUTS@{ub} id - numéro spécifiant le fichier à utiliser line$ - chaîne de caractères à écrire dans le fichier @{b}EXEMPLE@{ub} voir la commande @{"ReadChr()" LINK ReadChr} @ENDNODE @NODE WriteString "Guide Hollywood" @{b}NOM@{ub} WriteString -- écrire des octets dans un fichier @{b}SYNOPSIS@{ub} WriteString(id, data$, len) @{b}FONCTION@{ub} Cette commande peut être utilisé pour écrire un certain nombre d'octets dans un fichier. Les données sont spécifiée par la chaîne data$. Cette chaîne peut contenir du texte mais également des données binaires. Elles sont écrites dans le fichier dans le nombre d'octets spécifié par len (il n'est pas terminé par un caractère nul). Cette commande est particulièrement utile pour des données brutes d'Entrée/Sortie (E/S). @{b}INPUTS@{ub} id - numéro spécifiant le fichier à utiliser data$ - données à écrire dans un fichier len - octets à écrire dans un fichier @{b}EXEMPLE@{ub} size=FileSize("C:Assign") OpenFile(1,"C:Assign") OpenFile(2,"Ram:Copy_Of_Assign") data$=ReadString(1,size) WriteString(2,data$,size) CloseFile(2) CloseFile(1) Le code ci-dessus créé une copie de la commande "Assign" et la place dans "Ram:Copy_Of_Assign". @ENDNODE @NODE ReadString "Guide Hollywood" @{b}NOM@{ub} ReadString -- Lire des octets à partir d'un fichier @{b}SYNOPSIS@{ub} data$ = ReadString(id, length) @{b}FONCTION@{ub} Cette commande lit une longueur d'octets à partir du fichier spécifié par id et la renvois dans la chaîne data$. Vous pouvez lire des données binaires en utilisant cette commande. Bien que le résultat soit une chaîne, cette commande liera la vrai longueur d'octet à partir du fichier. Elle ne s'arrêtera pas même si un caractère nul apparait. Si de tels caractères particuliers sont présent dans votre fichier, votre chaîne ne sera pas très utile pour des commande tel que @{"Print()" LINK Print} mais vous pouvez l'utiliser par exemple pour écrire les données en utilisant la commande @{"WriteString()" LINK WriteString}. Cette commande est particulièrement utile pour des données brutes d'Entrée/Sortie (E/S). @{b}INPUTS@{ub} id - numéro spécifiant le fichier à utiliser length - nombre d'octets à lire @{b}RESULTATS@{ub} data$ - chaînes qui contient les caractères lus @{b}EXEMPLE@{ub} voir la commande @{"WriteString()" LINK WriteString} @ENDNODE @NODE Execute "Guide Hollywood" @{b}NOM@{ub} Execute -- exécuter un fichier de manière synchrone @{b}SYNOPSIS@{ub} Execute(file$) @{b}FONCTION@{ub} Cette commande exécute le fichier spécifié par file$ de manière synchrone. La chaîne file$ peut également contenir des arguments qui seront liés au programme. Si vous devez exécuter un programme asynchrone, vous devez utiliser la commande @{"Run()" LINK Run} @{b}INPUTS@{ub} file$ - ligne de commande ressemblant à une chaîne de caractères qui spécifie le fichier et les arguments @{b}EXEMPLE@{ub} Execute("Sys:Prefs/Locale") Le code ci-dessus exécute les préférences locale. Votre exécution de script sera arrêtée et reprendra lorsque l'utilisateur fermera les préférences locales (exécution synchrone). Execute("Echo >Ram:Test \\"Hello World\\"") Le code ci-dessus écrit " Hello World " dans un fichier créé "RAM:Test". @ENDNODE @NODE Run "Guide Hollywood" @{b}NOM@{ub} RUN -- exécuter un fichier de manière asynchrone @{b}SYNOPSIS@{ub} Run(file$) @{b}FONCTION@{ub} Cette commande exécute le fichier spécifié par file$ de façon asynchrone. La chaîne file$ peut également contenir des arguments qui seront liés au programme. Si vous devez exécuter un programme de manière synchrone, vous devez utiliser la commande @{"Execute()" LINK Execute}. @{b}INPUTS@{ub} file$ - ligne de commande ressemblant à une chaîne de caractères qui spécifie le fichier et les arguments @{b}EXEMPLE@{ub} Run("Sys:Prefs/Locale") Le code ci-dessus exécute les préférences Locale. Votre script continuera l'exécution immédiatement après avoir exécuté le programme Locale (exécution asynchrone). @ENDNODE @NODE FilePart "Guide Hollywood" @{b}NOM@{ub} FilePart -- renvoyer le nom d'un fichier à partir d'un chemin @{b}SYNOPSIS@{ub} file$=FilePart(path$) @{b}FONCTION@{ub} Cette commande extrait le nom de fichier à partir d'un chemin spécifié par path$ et le retourne. @{b}INPUTS@{ub} path$ - chemin de la source @{b}RESULTATS@{ub} file$ - nom du fichier @{b}EXEMPLE@{ub} f$=FilePart("dh0:Devs/DataTypes/ILBM") Print(f$) Le code ci-dessus affiche " ILBM " sur l'écran. @ENDNODE @NODE PathPart "Guide Hollywood" @{b}NOM@{ub} PathPart -- extraire un chemin @{b}SYNOPSIS@{ub} p$=PathPart(path$) @{b}FONCTION@{ub} Cette commande extrait un chemin à partir d'un chemin spécifié par path$ et le retourne. La partie du chemin retourné sera toujours terminé par " / " ou " : " de sorte que vous puissiez immédiatement ajouter un nom de fichier. @{b}INPUTS@{ub} path$ - chemin de la source @{b}RESULTATS@{ub} p$ - partie du chemin @{b}EXEMPLE@{ub} p$=PathPart("dh0:Devs/DataTypes/ILBM") Print(p$) Le code ci-dessus affiche " dh0:Devs/DataTypes/ " sur l'écran. @ENDNODE @NODE GetVolumeName "Guide Hollywood" @{b}NOM@{ub} GetVolumeName -- obtenir le nom d'un volume @{b}SYNOPSIS@{ub} Name$=GetVolumeName(vol$) @{b}FONCTION@{ub} Cette commande essaye d'obtenir le nom du volume spécifié par vol$. Le nom du volume est retourné dans Name$. @{b}INPUTS@{ub} vol$ - un volume DOS @{b}RESULTATS@{ub} Name$ - nom du volume @{b}EXEMPLE@{ub} n$=GetVolumeName("df0:") Print(n$) Le code ci-dessus affiche le nom du volume dans le lecteur df0: (s'il y en a). @ENDNODE @NODE ChangeDirectory "Guide Hollywood" @{b}NOM@{ub} ChangeDirectory -- changer le répertoire courant @{b}SYNOPSIS@{ub} ChangeDirectory(dir$) @{b}FONCTION@{ub} Cette commande modifie le répertoire courant à celui spécifiées par dir$. @{b}INPUTS@{ub} dir$ - répertoire qui définie le répertoire courant @{b}EXEMPLE@{ub} ChangeDirectory("S:") OpenFile(1,"Startup-Sequence") CloseFile(1) Le code ci-dessus modifie le répertoire courant par le répertoire " S: " et ouvre et ferme la Startup-Sequence. @ENDNODE @NODE ReadDirectory "Guide Hollywood" @{b}NOM@{ub} ReadDirectory -- Lire un répertoire dans un choix de chaîne @{b}SYNOPSIS@{ub} fcount, dcount = ReadDirectory(dir$,files$,dirs$) @{b}FONCTION@{ub} Cette commande examine le répertoire spécifié par dir$ et met tous les noms de fichier trouvés dans l'arborescences et les répertoires dans la chaîne spécifié par files$ et tous les noms des répertoires dans la chaîne spécifié par dirs$. Après le dernier item, cette commande insérera une chaîne vide dans le résultat, ainsi vous connaîtrez le nombre de fichiers et de répertoires qui ont été trouvés. Depuis Hollywood 2.0 Cette commande retourne 2 valeurs: La première valeur de renvoi indique le nombre de fichiers présent dans le répertoire et le second indique le nombre de sous-répertoires présent dans se même répertoire. @{b}INPUTS@{ub} dir$ - répertoire à examiner files$ - chaîne qui contient les noms de fichier dirs$ - chaîne qui contien les noms de sous répertoire @{b}RESULTATS@{ub} fcount - nombre de fichier dans dir$ (V2.0) dcount - nombre de sous-répertoire dans dir$ (V2.0) @{b}EXEMPLE@{ub} f$ = {} d$ = {} ReadDirectory("SYS:",f$,d$) Le code ci-dessus affiche le contenu de votre volume "SYS:" dans la chaîne f$ et d$. @ENDNODE @NODE MakeDirectory "Guide Hollywood" @{b}NOM@{ub} MakeDirectory -- Créer un nouveau répertoire (V1.5) @{b}SYNOPSIS@{ub} MakeDirectory(dir$) @{b}FONCTION@{ub} Cette commande créé un nouveau répertoire spécifié par dir$. Il retournera un message d'erreur si et seulement si le répertoire ne peut pas être créé. Si le répertoire spécifié par dir$ existe déjà, alors la commande sera annulé. Cette commande peut également créer plus d'un répertoire. MakeDirectory() balayera dir$ périodiquement et crééra chaque répertoire qui n'existe pas encore (Hollywood 1.9 et supérieur). @{b}INPUTS@{ub} dir$ - répertoire à créer @{b}EXEMPLE@{ub} MakeDirectory("Ram:Test") Le code ci-dessus créé un nouveau répertoire "RAM:Test ". MakeDirectory("Ram:A/B/C/D/E") Le code ci-dessus créé cinq nouveaux répertoires. @ENDNODE @NODE FullPath "Guide Hollywood" @{b}NOM@{ub} FullPath -- combiner répertoire et fichier dans un chemin spécifié - (V2.0) @{b}SYNOPSIS@{ub} path$ = FullPath(dir$, file$) @{b}FONCTION@{ub} Cette commande combine dir$ et file$ et renvoie un chemin @{b}INPUTS@{ub} dir$ - répertoire source file$ - fichier source @{b}EXEMPLE@{ub} path$ = FullPath("dh0:S", "Startup-Sequence") path$ reçoit la chaîne "dh0:S/Startup-Sequence". @ENDNODE @NODE CopyFile "Guide Hollywood" @{b}NOM@{ub} CopyFile -- copier un fichier ou un répertoire (V2.0) @{b}SYNOPSIS@{ub} CopyFile(src$, dst$[, newname$, func, userdata]) @{b}FONCTION@{ub} Cette commande copie le fichier ou le répertoire spécifié dans src$ au répertoire spécifié dans dst$. Veuillez noter que vous devez spécifier un répertoire, pas un fichier, dans dst$. Si vous voulez changer le nom du fichier tout en le copiant, utiliser l'argument optionnel newname$. Évidemment, cet argument est seulement utilisable quand vous spécifiez un fichier dans src$. Cette commande est puissante. elle est entièrement applicable dans tous les sous-répertoires et copie également les attributs du fichier, les données dates (création/modification etc...) et les commentaires. Si le répertoire de destination n'existe pas, il sera créé (même s'il contient des sous-répertoires qui n'existent pas encore). Toutes les spécifications du chemin peuvent être locales dans le répertoire courant ou définie. Vous pouvez également copier des fichiers au répertoire courant en spécifiant "" dans dst$. De plus, src$ peut contenir un chemin qui sera utilisé pour copier des fichiers sélectivement. Le paramètre optionnel func peut être utilisé pour faire passer une fonction de rappel qui sera appellé de temp en temp par la commande CopyFile(), ainsi vous pouvez mettre à jour une barre de progrèssion de copie. La fonction de rappel peut être également appelé si un fichier de destination existe déjà ou est écrit/protégé contre l'effacement. La fonction de rappel reçoit un argument : Un tableau qui contient des informations. Les rappels suivants sont disponibles: Fonction de rappel #COPYFILE_OVERWRITE: Action : #COPYFILE_OVERWRITE Source : Contient le chemin complet du fichier à copier. Destination : le chemin complet du fichier qui existe déjà. UserData : Contient la valeur que vous avez inséré dans l'argument userdata. La fonction de rappel du type #COPYFILE_OVERWRITE doit renvoyer TRUE si le fichier à été écrasé ou FALSE s'il à été annulé. Pour interrompre la fonction de copie, indiquer -1. * * * Fonction de rappel #COPYFILE_UNPROTECT: Action : #COPYFILE_UNPROTECT Destination : Contient le fichier destination protégé contre l'écriture ou l'effacement qui doit être déprotégé. UserData : Contient la valeur que vous avez inséré dans l'argument userdata. La fonction de rappel du type #COPYFILE_UNPROTECT sera appelé si le fichier qui devait être écrasé est protégé contre l'écriture ou l'effacement. Cette fonction de rappel doit renvoyer TRUE, s'il est en accord sur le fait q'un fichier n'es pas protégé ou FALSE s'il est protégé. Si vous indiquez -1, la fonction de copie sera interrompu. * * * Fonction de rappel #COPYFILE_STATUS: Action : #COPYFILE_STATUS Source : Contient le chemin complet du fichier qui est actuellement copié (source). Destination : Contient le chemin complet du fichier qui est actuellement copié (destination). Copied : Contient le nombre d'octets qui ont été déjà copiés. Filesize : Contient la taille du fichier source. UserData : Contient la valeur que vous avez inséré dans l'argument userdata. La fonction de rappel du type #COPYFILE_STATUS devrait normalement retourner FALSE. S'il renvoie TRUE, la fonction de copie sera interrompue. note importante : si vous ne spécifiez pas une fonction de rappel, les fichiers existant seront écrasé. S'ils sont protégés contre l'écriture et l'effacement, la fonction de copie les annulera. Depuis Hollywood 3.1 il y a un argument optionnel appelé "userdata". La valeur que vous spécifiez ici est lié à votre fonction de rappel chaque fois qu'elle s'appelle. C'est utile si vous voulez éviter de travailler avec des variables globales. En utilisant l'argument "userdata" vous pouvez lié facilement des données à votre fonction de rappel. Vous pouvez spécifier une valeur de n'importe quel type dans "userdata". Nombres, chaînes, tableaux, et commandes peuvent être lié comme données utilisateurs. @{b}INPUTS@{ub} src$ - fichier source ou répertoire a copier dst$ - répertoire de destination newname$ - optionnel: nouveau nom pour le fichier si src$ est un fichier; inséré une chaîne vide "" si vous n'avez pas besoin de cet item mais que vous voulez spécifier une fonction de rappel func - optionnel: fonction à appeler quand une erreur apparaît userdata - optionnel: données utilisateurs particulières à lié à la fonction de rappel (V3.1) @{b}EXEMPLE@{ub} CopyFile("S:", "Ram:Bak_S") Créé un backup de votre tiroir S : dans Ram:Bak_S (sera créé par Cette fonction). ---------------------- CopyFile("Dev:Hollywood/WarpOS/#?.(c|h)", "Ram:HW_BAK") Copie tous les fichiers de codes sources et d'en-tête de Dev:Hollywood/WarpOS à Ram:HW_BAK. ---------------------- FONCTION p_CopyCallback(msg) Switch msg.action Case #COPYFILE_STATUS: DebugPrint("Copie les fichiers", FilePart(msg.source), "vers", PathPart(msg.destination)) Case #COPYFILE_OVERWRITE: Return(SystemRequest("Hollywood", FilePart(msg.destination) .. " doit déjà exister!\\n" .. "Voulez-vous que j'écrase les fichiers?", "Yes|No")) Case #COPYFILE_UNPROTECT: Return(SystemRequest("Hollywood", FilePart(msg.destination) .. " est protégé en Ecriture/effacaement!\\n" .. "Vouloez-vous que je les déprotèges?", "Yes|No")) EndSwitch Return(False) EndFunction CopyFile("S:", "Ram:Copy_of_S", "", p_CopyCallback) Démonstration sur l'utilisation d'une fonction de rappel. @ENDNODE @NODE Rename "Guide Hollywood" @{b}NOM@{ub} Rename -- renommer un fichier ou un répertoire (V2.0) @{b}SYNOPSIS@{ub} Rename(oldname$, newname$) @{b}FONCTION@{ub} Cette commande renomme un fichier ou un répertoire. oldname$ est le nom du fichier ou du répertoire à renommer et peut également contenir un chemin spécifié. newname$ est juste le nouveau nom désiré pour le fichier/répertoire et ne doit pas contenir un chemin. @{b}INPUTS@{ub} oldname$ - fichier ou répertoire à renommer newname$ - nouveau nom pour le fichier/répertoire @{b}EXEMPLE@{ub} Rename("dh0:Prefs/Locale", "Locale1") Renomme les préférences de lieu dans Prefs par Locale1. @ENDNODE @NODE IsDirectory "Guide Hollywood" @{b}NOM@{ub} IsDirectory -- vérifier le fichier ou le répertoire (V2.0) @{b}SYNOPSIS@{ub} r = IsDirectory (f$) @{b}FONCTION@{ub} Cette commande contrôles si f$ est un fichier ou un répertoire. Si c'est un répertoire, cette commande renvoie TRUE, sinon FALSE si c'est un fichier. @{b}INPUTS@{ub} f$ - objet fichiers système (répertoire ou fichier) @{b}RESULTATS@{ub} r - TRUE si f$ sont un répertoire, FALSE si un fichier @{b}EXEMPLE@{ub} r = IsDirectory("S:") Ceci renvoie TRUE, car c'est un répertoire. @ENDNODE @NODE CRC32 "Guide Hollywood" @{b}NOM@{ub} CRC32 -- calcule de contrôle 32 bits d'un fichier (V2.0) @{b}SYNOPSIS@{ub} chk = CRC32(f$) @{b}FONCTION@{ub} Cette commande calcule la somme de contrôle cyclique de suppression d'utilisation de 32 Bits (CRC32) pour un fichier donné. Cette somme de contrôle vous permet d'identifier vos fichiers. @{b}INPUTS@{ub} f$ - fichier source @{b}RESULTATS@{ub} chk - CRC32 de 32 bits de f$ @ENDNODE @NODE ReadInt "Guide Hollywood" @{b}NOM@{ub} ReadInt -- lire un nombre entier à partir d'un fichier (V2.0) @{b}SYNOPSIS@{ub} int = ReadInt(id) @{b}FONCTION@{ub} Cette commande lit un nombre entier signé à partir du fichier spécifié par id et retourne sa valeur. La lecture commence à partir de la position du curseur du fichier actuel que vous pouvez modifier en utilisant la commande @{"Seek()" LINK Seek}. Un nombre entier est défini sur 4 octets. La valeur retournée sera signée et s'échelonnera de -2147483648 à 2147483647. Si vous devez enregistrer de plus grandes valeurs, vous devriez utiliser la commande @{"WriteFloat()" LINK WriteFloat} qui utilise les valeurs 64-bit. Cette commande s'attend à ce que la valeur soit enregistré dans le MSB (Most Significative Byte en premier). @{b}INPUTS@{ub} id - fichier où doit être lu les données @{b}RESULTATS@{ub} int - nombre entier @ENDNODE @NODE ReadShort "Guide Hollywood" @{b}NOM@{ub} ReadShort -- lire un nombre court à partir d'un fichier (V2.0) @{b}SYNOPSIS@{ub} short = ReadShort(id) @{b}FONCTION@{ub} Cette commande lit une valeur courte sans signature à partir du fichier spécifié par id et la renvois. La lecture commence à partir du curseur du fichier actuel que vous pouvez modifier en utilisant la commande @{"Seek()" LINK Seek}. Un nombre court est défini sur 2 octets. La valeur retournée sera sans signature et s'échelonnera de 0 à 65535. Si vous devez enregistrer des valeurs signées, utiliser la commande @{"WriteInt()" LINK WriteInt}. Cette commande s'attend à ce que la valeur soit enregistré dans le MSB (Most Significative Byte en premier). @{b}INPUTS@{ub} id - fichier où doit être lu les données @{b}RESULTATS@{ub} short - nombre court dans la fourchette de 0 à 65535 @ENDNODE @NODE ReadFloat "Guide Hollywood" @{b}NOM@{ub} ReadFloat -- Lire un chiffre à virgule flottante à partir d'un fichier (V2.0) @{b}SYNOPSIS@{ub} float = ReadFloat(id) @{b}FONCTION@{ub} Cette commande lit une valeur signée à virgule flottante à partir du fichier spécifié par id et la renvois. La lecture commence à partir du curseur du fichier actuel que vous pouvez modifier en utilisant la commande @{"Seek()" LINK Seek}. La valeur d'un nombre à virgule flottante est définie sur 8 octets, se qui est assez pour enregistrer de grands nombres entiers et à virgule flottante avec plusieurs décimales. Cette commande s'attend à ce que la valeur soit enregistré dans le MSB (Most Significative Byte en premier). @{b}INPUTS@{ub} id - fichier où doit être lu les données @{b}RESULTATS@{ub} float - nombre à virgule @ENDNODE @NODE WriteInt "Guide Hollywood" @{b}NOM@{ub} WriteInt -- écrire un nombre entier dans un fichier (V2.0) @{b}SYNOPSIS@{ub} WriteInt(id, int) @{b}FONCTION@{ub} Cette commande écrit un nombre entier signé dans un fichier spécifié par id à la position du curseur du fichier actuel que vous pouvez modifier en utilisant la commande @{"Seek()" LINK Seek}. Un nombre entier utilisera 4 octets d'espace disque. La valeur à écrire dans le fichier peut s'échelonner de -2147483648 à 2147483647. Si vous devez enregistrer de plus grandes valeurs, vous devez utiliser la commande @{"WriteFloat()" LINK WriteFloat} qui utilise les valeurs 64-bit. Cette commande enregistre la valeur dans le MSB (Most Significative Byte en premier). @{b}INPUTS@{ub} id - fichier à écrire int - nombre entier à écrire dans un fichier @ENDNODE @NODE WriteShort "Guide Hollywood" @{b}NOM@{ub} WriteShort -- écrire un nombre court dans un fichier (V2.0) @{b}SYNOPSIS@{ub} WriteShort(id, short) @{b}FONCTION@{ub} Cette commande sauve un nombre entier court sans signature dans un fichier spécifié par id à la position du curseur du fichier actuel que vous pouvez modifier en utilisant la commande @{"Seek()" LINK Seek}. Un nombre entier court utilisera 2 octets d'espace disque. La valeur à écrire dans le fichier peut s'échelonner de 0 à 65535. Si vous avez besoin de valeurs signées,utiliser la commande @{"WriteInt()" LINK WriteInt}. Cette commande enregistre la valeur dans le MSB (Most Significative Byte en premier). @{b}INPUTS@{ub} id - fichier à écrire short - nombre court à écrire dans un fichier @ENDNODE @NODE WriteFloat "Guide Hollywood" @{b}NOM@{ub} WriteFloat -- écrire un nombre à virgule flottante dans un fichier (V2.0) @{b}SYNOPSIS@{ub} WriteFloat(id, float) @{b}FONCTION@{ub} Cette commande écrit un nombre à virgule flottante signé dans un fichier spécifié par id à la position du curseur du fichier actuel que vous pouvez modifier en utilisant la commande@{"Seek()" LINK Seek}. Un nombre à virgule flottante utilisera 8 octets d'espace disque ce qui est suffisant pour enregistrer de grands nombres entiers et à virgule flottante avec plusieurs décimales. Cette fonction enregistre la valeur dans le MSB (Most Significative Byte en premier). @{b}INPUTS@{ub} id - fichier à écrire float - nombre à virgule à écrire dans un fichier @ENDNODE @NODE FilePos "Guide Hollywood" @{b}NOM@{ub} FilePos -- retourner la position du curseur du fichier (V2.0) @{b}SYNOPSIS@{ub} pos = FilePos(id) @{b}FONCTION@{ub} Cette commande renvoie la position du curseur de fichier du fichier spécifié par id le curseur démarre à 0 (début du fichier) et la fin correspond à la taille du fichier. Vous pouvez utiliser cette fonction pour découvrir où vous êtes dans un fichier parce que toutes lecture et écriture de données commenceront à cette position de curseur. Vous pouvez utiliser la commande @{"Seek()" LINK Seek} pour modifier la position du curseur du fichier. @{b}INPUTS@{ub} id - identité du fichier à questionner @{b}RESULTATS@{ub} pos - position du curseur de ce fichier @{b}EXEMPLE@{ub} OpenFile(1, "S:Startup-Sequence", #MODE_READ) Seek(1, 1024) Print(FilePos(1)) CloseFile(1) Ceci affiche 1024. @ENDNODE @NODE MatchPattern "Guide Hollywood" @{b}NOM@{ub} MatchPattern -- vérifier si un élément correspond avec une chaîne (V2.0) @{b}SYNOPSIS@{ub} bool = MatchPattern(src$, pattern$) @{b}FONCTION@{ub} Cette commande contrôle si la chaîne spécifié dans src$ correspond à l'élément spécifié dans pattern$. Si ils correspondent, TRUE sera retourné ou sinon se sera FALSE. @{b}INPUTS@{ub} src$ - chaîne source pattern$ - élément à comparer avec la chaîne @{b}RESULTATS@{ub} bool - TRUE si la chaîne correspond à l'élément, sinon FALSE @{b}EXEMPLE@{ub} r = MatchPattern("dh0:Picvousres/JPG/Pic1.jpg", "*.jpg") Renvoie TRUE parce que la chaîne correspond à l'élément. @ENDNODE @NODE SetIOMode "Guide Hollywood" @{b}NOM@{ub} SetIOMode -- commuter les E/S entre mis en mémoire tampon et sans mémoire tampon (V2.5) @{b}SYNOPSIS@{ub} SetIOMode(mode) @{b}FONCTION@{ub} Cette commande peut être utilisé pour spécifier le mode de la gestion mémoire des E/S que les fonctions de La bibliothèque DOS Hollywood utiliseront. Par défaut, toute les fonctions DOS E/S utiliseront la mis en mémoire tampon. C'est particulièrement efficace pour des petites opérations de lecture et écriture. Pour quelques cas, l'E/S mis en mémoire tampon n'est pas très efficace et vous devrez utiliser l'E/S sans mémoire tampon. Par exemple, quand vous utiliser le port parallèle en utilisant la bibliothèque DOS ou que vous avez ouvert une fenêtre console en utilisant la commande @{"OpenFile()" LINK OpenFile}. Dans ces cas les E/S sans mémoire tampon doivent être préféré puisque les données sont liées directement au système de fichiers. Le mode que vous réglez en utilisant cette commande est respecté par toutes les fonctions de la bibliothèque DOS mais noter bien que si vous commutez les E/S entre mis en mémoire tampon et sans mémoire tampon sur le même fichier vous devez utiliser la commande @{"FlushFile()" LINK FlushFile} pour vider toutes les mémoires tampons. Si vous oubliez d'effectuer cette action, vous pourriez obtenir des erreurs avec des données mis à de mauvaises positions dans votre fichier. Cette fonction doit être utilisé par des utilisateurs chevronnés. Normalement, vous n'avez pas à modifier le mode de gestion mémoire des E/S. @{b}INPUTS@{ub} mode - mode désiré d'E/S pour la bibliothèque DOS; ceci peut être #IO_BUFFERED ou #IO_UNBUFFERED (par défaut, Hollywood utilise toujours le #IO_BUFFERED) @ENDNODE @NODE FlushFile "Guide Hollywood" @{b}NOM@{ub} FlushFile -- vider toutes les mémoires tampons en instance (V2.5) @{b}SYNOPSIS@{ub} FlushFile(id) @{b}FONCTION@{ub} Cette commande vide toutes les mémoires tampons en instance du fichier spécifié par id et rajuste le curseur de fichier. Il est important que vous appeliez cette commande si vous commutez la gestion mémoire des E/S entre mis en mémoire tampon et sans mémoire tampon sur le même fichier. Si vous n'utilisez pas la commande @{"SetIOMode()" LINK SetIOMode}, vous ne devez pas vous inquiéter au sujet de l'effacement du contenu des mémoires tampons puisque cela sera fait automatiquement par le système de fichiers si vous utilisez seulement la gestion mémoire des E/S avec utilisation de la mémoire tampon. @{b}INPUTS@{ub} id - identité du fichier à vider @ENDNODE @NODE ProtFlagsInfo "Guide Hollywood" @{b}Information sur les attributs de protection@{ub} Les commandes @{"GetFileAttributes()" LINK GetFileAttributes} et @{"SetFileAttributes()" LINK SetFileAttributes} vous permettent d'obtenir et de régler les attributs de protection d'un fichier ou d'un répertoire. Les attributs sont retournés et régler dans un tableau unique appelé "flags". Ce flags contient le bitmask (masque binaire) qui est une combinaison des attributs actifs. Comme les attributs de protection dépendent du système de fichiers de l'OS, ces attributs ne sont pas tous indiqué ci-après, seulement ceux qui sont compatible. Voir les crochet afin de connaître sur qu'elle système ces attributs fonctionne. Les attributs suivants sont identifiés par Hollywood : #FILEATTR_READ_USR [AmigaOS, Mac OS] #FILEATTR_WRITE_USR [AmigaOS, Mac OS] #FILEATTR_DELETE_USR [AmigaOS] #FILEATTR_EXECUTE_USR [AmigaOS, Mac OS] #FILEATTR_READ_GRP [Mac OS] #FILEATTR_WRITE_GRP [Mac OS] #FILEATTR_EXECUTE_GRP [Mac OS] #FILEATTR_READ_OTH [Mac OS] #FILEATTR_WRITE_OTH [Mac OS] #FILEATTR_EXECUTE_OTH [Mac OS] #FILEATTR_PURE [AmigaOS] #FILEATTR_ARCHIVE [AmigaOS, Win32] #FILEATTR_SCRIPT [AmigaOS] #FILEATTR_HIDDEN [Win32] #FILEATTR_SYSTEM [Win32] #FILEATTR_READONLY [Win32] Pour régler certains de ces attributs pour un fichier, il faut simplement les combiner en utilisant @{"Bit ou opérateur" LINK V6PrgOprBitw}. Par Exemple: t = {} t.flags = #FILEATTR_READ_USR | #FILEATTR_WRITE_USR SetFileAttributes("test.txt", t) Le code ci-dessus donnera une autorisation de lecture et d'écriture au fichier "test.txt". Mais noter, que ce code ne fonctionnerait pas correctement sous Win32 parce que Win32 ne connait pas ces deux attributs. Pour vérifier si un attribut est activé, utiliser @{"Bit ou opérateur" LINK V6PrgOprBitw}. Par Exemple: t = GetFileAttributes("test.txt") If t.flags & #FILEATTR_READ_USR) Then Print("#FILEATTR_READ_USR is set.") Il y a un autre attribut nommé #FILEATTR_NORMAL. Cet attribut a une signification spéciale et peut seulement être utiliser avec SetFileAttributes() et elle ne peut pas être combiné avec d'autres attributs. Quand vous indiquez #FILEATTR_NORMAL à SetFileAttributes(), les attributs de protection de fichier seront remis à l'état initial, entre autre aux valeurs par défauts du système d'exploitation, qui diffèrent selon la plate-forme. @ENDNODE @NODE GetFileAttributes "Guide Hollywood" @{b}NOM@{ub} GetFileAttributes -- obtenir les attributs d'un fichier ou d'un répertoire (V3.0) @{b}SYNOPSIS@{ub} t = GetFileAttributes(f$) @{b}FONCTION@{ub} Cette commande renvoie un tableau qui contient les attributs d'un fichier ou d'un répertoire. Ceci comprend l'information telle que le temps de création du fichier, le chemin complet du fichier, des attributs de protection, et bien plus, selon le système de fichiers et l'OS. Indiquer le nom d'un fichier ou d'un répertoire avec cette commande. Vous pouvez spécifier une chaîne vide ("") afin d'obtenir des informations dans le répertoire courant. Les données retounées, par l'intermédiaire d'un tableau, auront les attributs suivants : Type : Ce sera #DOSTYPE_FILE si f$ est un fichier ou #DOSTYPE_DIRECTORY si f$ est un répertoire. Path : Cet indicateur contiendra une chaîne avec le chemin complet de ce fichier ou répertoire. Size : Cet indicateur sera seulement présent si f$ est un fichier. Dans se cas, cet indicateur recevrà la taille du fichier en octets. flags : Cet indicateur recevra une combinaison des attributs de protection du fichier ou du répertoire. Voir le chapitre @{"information sur les attributs de protection" LINK ProtFlagsInfo} pour plus d'information. Time : Cet indicateur recevra une chaîne contenant la date de la dernière modification du fichier ou du répertoire. La chaîne sera toujours dans le format dd-mmm-yyyy hh:mm:ss. Par Exemple: 08-Nov-2004 14:32:13 LastAccessTime : Cet indicateur recevra une chaîne contenant la date de la dernière consultation du fichier ou du répertoire. Cet indicateur est seulement disponible sur Win32 et Mac OS. CreationTime : Cet indicateur recevra une chaîne contenant la date de création du fichier ou du répertoire. Cet indicateur est seulement disponible sur Win32. Comment : Cet indicateur contiendra le commentaire d'un fichier. Seulement disponible sur Amiga OS. @{b}INPUTS@{ub} f$ - nom du fichier ou du répertoire à examiner @{b}RESULTATS@{ub} t - un tableau initialisé comme montré ci-dessus @{b}EXEMPLE@{ub} t = GetFileAttributes("test.txt") Print(t.time) If t.flags & #FILEATTR_READ_USR Print("#FILEATTR_READ_USR is set.") Else Print("#FILEATTR_READ_USR is not set.") EndIf Le code ci-dessus examine le fichier " test.txt " et affiche la date de la dernière modification à l'écran. De plus, il vérifie si l'indicateur de protection #FILEATTR_READ_USR est activé. @ENDNODE @NODE SetFileAttributes "Guide Hollywood" @{b}NOM@{ub} SetFileAttributes -- activer les attributs d'un fichier ou d'un répertoire (V3.0) @{b}SYNOPSIS@{ub} SetFileAttributes(f$, t) @{b}FONCTION@{ub} Cette commande peut être utilisé pour changer un ou de multiples attributs de fichier ou de répertoire. Ceci comprend l'information telle que la date de création du fichier, les attributs de protection, et bien plus, selon le système de fichiers de l'OS. Le fichier (ou répertoire) dont vous voulez changer les attributs doit être défini dans le paramètre f$. Le deuxième paramètre est un tableau qui contient tous les attributs que vous voulez modifier. Les attributs suivants peuvent être réglés dans le tableau: Flags : Utiliser cet indicateur pour changer les attributs de protection du fichier ou répertoire. Régler cet indicateur avec une combinaison d'attributs de protection ou a #FILEATTR_NORMAL pour remettre à l'état initial tous les attributs de protection. Voir le chapitre @{"information sur les attributs de protection" LINK ProtFlagsInfo} pour plus d'information. Time : Utiliser cet indicateur pour changer le groupe date/heure du fichier ou répertoire. Cet indicateur peut être utilisé pour changer la date de la dernière modification. Vous devez régler cet indicateur à une chaîne de caractères dans le format dd-mmm-yyyy hh:mm:ss Par Exemple: 08-Nov-2004 14:32:13. LastAccessTime : Utiliser cet indicateur pour modifier la date de dernière consultation du fichier ou du répertoire La chaîne que vous spécifiez ici doit être dans le format dd-mmm-yyyy hh:mm:ss. Cet attribut est seulement disponible sur Win32 et Mac OS. CreationTime : cet indicateur pour modifier la date de création du fichier ou du répertoire. La chaîne que vous spécifiez ici doit être au format dd-mmm-yyyy hh:mm:ss. Cet attributs est seulement disponible sur Win32. Comment : cet indicateur pour changer le commentaire d'un fichier. Ceci est seulement disponible sur Amiga OS. @{b}INPUTS@{ub} f$ - nom de fichier ou répertoire dont les attributs doivent être changés t - un tableau contenant les attributs à activé/désactivé @{b}EXEMPLE@{ub} t = {} t.time = "15-Dec-2006 23:30:12" t.flags = #FILEATTR_READ_USR | #FILEATTR_WRITE_USR SetFileAttributes("test.txt", t) Le code ci-dessus défini la date/heure du fichier " test.txt " au 15 décembre 2006 à 23h30 12 secondes. il règle les attributs de protection #FILEATTR_READ_USR et #FILEATTR_WRITE_USR. @ENDNODE @NODE GetTempFileName "Guide Hollywood" @{b}NOM@{ub} GetTempFileName -- retourner le nom d'un fichier temporaire (V3.0) @{b}SYNOPSIS@{ub} f$ = GetTempFileName() @{b}FONCTION@{ub} Cette commande peut être utilisé pour obtenir un fichier que vous pouvez utiliser temporairement. C'est utile au cas où vous devriez temporairement stocker des informations dans un fichier que vous effacerez plus tard. Hollywood effacera tous les fichiers temporaires automatiquement quand il s'arrêtera mais vous pouvez également faire cette manipulation manuellement en utilisant la commande @{"DeleteFile()" LINK DeleteFile}. Il est préférable d'utiliser cette fonction si vous devez travailler avec des fichiers temporaires parce que chaque système d'exploitation stocke ses fichiers temporaires à des endroit différent. En utilisant cette commande vous pouvez être sûr que vos fichiers temporaires seront effacés à partir du bon répertoire. @{b}INPUTS@{ub} aucun @{b}RESULTATS@{ub} f$ - nom de fichier que vous pouvez utiliser pour des opérations temporaires @{b}EXEMPLE@{ub} f$ = GetTempFileName() OpenFile(1, f$, #MODE_WRITE) WriteLine(1, "Mon fichier temporaire") CloseFile(1) Le code ci-dessus obtiendra le nom d'un fichier temporaire et sauvera un texte dans celui-ci. Le fichier sera automatiquement effacé quand Hollywood s'arrêtera. @ENDNODE @NODE FileLength "Guide Hollywood" @{b}NOM@{ub} FileLength -- obtenir la taille d'un fichier ouvert (V3.0) @{b}SYNOPSIS@{ub} size = FileLength(id) @{b}FONCTION@{ub} Cette commande renvoie la taille actuelle du fichier spécifié par id la taille retournée par cette commande sera mise à jour avec toutes les opérations effectués sur ce fichier. Par exemple, vous pourriez écrire dans le fichier et FileLength() renverrait la nouvel taille du fichier. @{b}INPUTS@{ub} id - identité du fichier à questionner @{b}RESULTATS@{ub} size - taille actuelle de ce fichier @{b}EXEMPLE@{ub} OpenFile(1, "test.txt", #MODE_WRITE) NPrint(FileLength(1)) WriteLine(1, "Hello World.") NPrint(FileLength(1)) CloseFile(1) Le code ci-dessus ouvre le fichier " test.txt " pour y écrire et appelle FileLength() deux fois. Le premier appel renverra 0 puisque le fichier est vide à l'instant 0 mais le deuxième appel renverra 13 puisque quelques caractères ont été écrit dans se fichier. @ENDNODE @NODE CompressFile "Guide Hollywood" @{b}NOM@{ub} CompressFile -- compresser un fichier (V4.0) @{b}SYNOPSIS@{ub} size = CompressFile(src$, dst$) @{b}FONCTION@{ub} Cette commande compresse le fichier src$ et sauvegarde les données compressées à dst$. La valeur de renvoi spécifie la taille du fichier compressé. Hollywood utilise la zlib pour la compression de données. Pour décompresser les fichiers compresser par CompressFile(), utiliser la commande Hollywood @{"DecompressFile()" LINK DecompressFile}. @{b}INPUTS@{ub} src$ - fichier à compresser dst$ - fichier de sortie @{b}RESULTATS@{ub} size - taille du fichier compressé @{b}EXEMPLE@{ub} CompressFile("image.bmp", "image.pak") Le code ci-dessus compresse le fichier image.bmp et le sauvegarde en image.pak. @ENDNODE @NODE DecompressFile "Guide Hollywood" @{b}NOM@{ub} DecompressFile -- décompresser un fichier (V4.0) @{b}SYNOPSIS@{ub} size = DecompressFile(src$, dst$) @{b}FONCTION@{ub} Cette commande décompresse le fichier src$ et sauvegarde les données décompressé à dst$. Le fichier doit avoir été compressé par la commande @{"CompressFile()" LINK CompressFile}. La valeur retourné spécifie la taille du fichier décompressé. @{b}INPUTS@{ub} src$ - fichier à décompresser dst$ - fichier de sortie @{b}RESULTATS@{ub} size - taille du fichier décompressé @{b}EXEMPLE@{ub} DecompressFile ("image.pak", "image.bmp") Le code ci-dessus décompresse le fichier image.pak en image.bmp. @ENDNODE @NODE OpenDirectory "Guide Hollywood" @{b}NOM@{ub} OpenDirectory -- ouvrir un répertoire pour examination (V4.0) @{b}SYNOPSIS@{ub} [id] = OpenDirectory(id, dir$) @{b}FONCTION@{ub} Cette commande ouvre le répertoire spécifié dans dir$ et lui affecte id comme identification. Si vous indiquez @{"Nil" LINK V6PrgTypeNil} comme id, OpenDirectory() choisira automatiquement une id vide et la retournera. Le répertoire peut par la suite être examiné en utilisant la commande @{"NextDirectoryEntry()" LINK NextDirectoryEntry} ce qui vous donne un accès de bas niveau au répertoire, ce qui est particulièrement utile pour des répertoires volumineux ou si vous avez besoin d'informations complémentaires comme des tailles/attributs pour les différentes entrées de répertoire. Vous pouvez obtenir ces informations très rapidement en utilisant une boucle comme présentée dans l'exemple ci-dessous. Vous devrez appeler @{"CloseDirectory()" LINK CloseDirectory} dès que vous aurez terminé avec le répertoire. Ceci s'assure que le répertoire ne reste pas verrouillé par le système de fichiers. @{b}INPUTS@{ub} id - id pour le répertoire ou @{"Nil" LINK V6PrgTypeNil} pour la @{"sélection automatique d'id" LINK AutoIDSelect} dir$ - nom du répertoire à ouvrir @{b}RESULTATS@{ub} id - optionnel: identité du répertoire; sera seulement retourné quand vous indiquerez @{"Nil" LINK V6PrgTypeNil} comme argument 1 (voir ci-dessus) @{b}EXEMPLE@{ub} OpenDirectory(1, "SYS:") e = NextDirectoryEntry(1) While e <> Nil NPrint(IIf(e.type = #DOSTYPE_FILE, "File:", "Directory:"), e.name) e = NextDirectoryEntry(1) Wend CloseDirectory(1) Le code ci-dessus ouvre le répertoire "SYS:" et affiche tous les fichiers et répertoires à l'écran. @ENDNODE @NODE NextDirectoryEntry "Guide Hollywood" @{b}NOM@{ub} NextDirectoryEntry -- obtenir la prochaine entrée à partir d'un répertoire ouvert (V4.0) @{b}SYNOPSIS@{ub} t = NextDirectoryEntry(id) @{b}FONCTION@{ub} Cette comande obtient la prochaine entrée à partir d'un répertoire précédemment ouvert en utilisant la commande @{"OpenDirectory()" LINK OpenDirectory}. La commande retournera un tableau détaillé qui contient les informations sur l'entrée recherchée. Si il n'y a plus d'entrées dans le répertoire spécifié, cette commande retournera @{"Nil" LINK V6PrgTypeNil}. Normalement, cette commande est appellé dans une boucle jusqu'à ce qu'elle renvoie Nil. De cette façon que vous pouvez balayer le contenu complet d'un répertoire. Le tableau qui est retourné par cette commande aura les indicateurs suivant: Name : Cet indicateur contiendra le nom de l'entrée. Type : Ce sera #DOSTYPE_FILE si l'entrée est un fichier ou #DOSTYPE_DIRECTORY si l'entrée est un répertoire. Size : Cet indicateur sera seulement présent si l'entrée est un fichier. Dans ce cas, cet indicateur recevrà la taille du fichier en octets. Flags : Cet indicateur recevra une combinaison des attributs de protection du fichier ou du répertoire. Voir @{"les attributs de protections" LINK ProtFlagsInfo} pour plus d'information. Time : Cet indicateur recevra une chaîne contenant la date de la dernière modification du fichier ou du répertoire. La chaîne sera toujours dans le format dd-mmm-yyyy hh:mm:ss. Par Exemple: 08-Nov-2004 14:32:13. LastAccessTime : Cet indicateur recevra une chaîne contenant la date de la dernière consultation du fichier ou du répertoire. Cet indicateur est seulement disponible sur Win32 et Mac OS. CreationTime : Cet indicateur recevra une chaîne contenant la date de création du fichier ou du répertoire. Cet attribut est seulement disponible sur Win32. Comment : Cet indicateur contiendra le commentaire d'un fichier. C'est seulement disponible sur Amiga OS. @{b}INPUTS@{ub} id - id du répertoire à questionner @{b}RESULTATS@{ub} t - un tableau initialisé comme montré ci-dessus @{b}EXEMPLE@{ub} voir @{"OpenDirectory()" LINK OpenDirectory} @ENDNODE @NODE CloseDirectory "Guide  Hollywood" @{b}NOM@{ub} CloseDirectory -- fermer un répertoire ouvert (V4.0) @{b}SYNOPSIS@{ub} CloseDirectory (id) @{b}FONCTION@{ub} Cette commande ferme un répertoire précédemment ouvert en utilisant la commande @{"OpenDirectory()" LINK OpenDirectory}. Vous devez toujours fermer les répertoires dès que vous aurez terminé avec eux. Ceci assure que le système de fichiers ne fait pas que les répertoires restes inutilement verrouillé. @{b}INPUTS@{ub} id - identité du répertoire à fermer @{b}EXEMPLE@{ub} voir @{"OpenDirectory()" LINK OpenDirectory} @ENDNODE @NODE WriteFunction "Guide Hollywood" @{b}NOM@{ub} WriteFunction -- écrire une fonction dans un fichier (V4.0) @{b}SYNOPSIS@{ub} WriteFunction(id, func[, txtmode]) @{b}FONCTION@{ub} Cette commande écrit une fonction Hollywood spécifié par func dans un fichier spécifié par id à la position du curseur du fichier actuel que vous pouvez modifier par l'utilisation de la commande @{"Seek()" LINK Seek}. La fonction sera écrite dans un fichier comme un code précompilé, c.-à-d. qu'il ne sera pas lisible pour l'utilisateur. Vous pouvez lire des fonctions sauvegardés dans d'autres projets par l'utilisation de la commande @{"ReadFunction()" LINK ReadFunction}. L'argument optionnel txtmode spécifie si ou non la fonction sera écrite dans le fichier en tant que donnée binaires ou en tant que donnée codées en base64. ce dernier est utile pour inclure des fonctions Hollywood en fichier texte compréhensible pour l'utilisateur, par exemple des fichiers XML. @{b}INPUTS@{ub} id - fichier à écrire func - fonction à écrire dans le fichier txtmode - optionnel: TRUE pour écrire la fonction en base64 ou FALSE pour écrire en données binaires ordinaires (défauts à FALSE) @{b}EXEMPLE@{ub} FONCTION p_LittleTestFunc(a, b) Return(a+b) EndFunction OpenFile(1, "func.bin", #MODE_WRITE) WriteFunction(1, p_LittleTestFunc) CloseFile(1) OpenFile(1, "func.bin", #MODE_READ) p_MyAdd = ReadFunction(1) CloseFile(1) Print(p_MyAdd(5, 6)) ; affiche 11 Le code ci-dessus écrit la fonction p_LittleTestFunc() dans le fichier "func.bin". Ensuite, il ouvre le fichier "func.bin" de nouveau et relit la fonction avec Hollywood. La fonction importée sera enregistrée dans la variable p_MyAdd (). En conclusion, nous appellerons la nouvelle fonction p_MyAdd() et elle effecuera l'addition des numéros 5 et 6. @ENDNODE @NODE ReadFunction "Guide Hollywood" @{b}NOM@{ub} ReadFunction -- lire une fonction à partir d'un fichier (V4.0) @{b}SYNOPSIS@{ub} func = ReadFunction(id) @{b}FONCTION@{ub} Cette commande lit une fonction Hollywood à partir du fichier spécifié par id et la retourne. La lecture commence à partir de la position du curseur du fichier actuel que vous pouvez modifier en utilisant la commande @{"Seek()" LINK Seek}. La fonction doit avoir été écrite dans un fichier par la commande @{"WriteFunction()" LINK WriteFunction} @{b}INPUTS@{ub} id - fichier à lire @{b}RESULTATS@{ub} func - la fonction à lire à partir du fichier @{b}EXEMPLE@{ub} voir la commande @{"WriteFunction()" LINK WriteFunction} @ENDNODE @NODE DefineVirtualFile "Guide Hollywood" @{b}NOM@{ub} DefineVirtualFile -- définir un fichier virtuel à l'intérieur d'un fichier réel (V4.0) @{b}SYNOPSIS@{ub} virtfile$ = DefineVirtualFile(file$, offset, size, name$) @{b}FONCTION@{ub} Cette commande vous permet de définir un fichier virtuel à l'intérieur d'un autre fichier, ce qui peut être utile dans plusieurs situations. Imaginer que vous travaillez à la création d'un jeu et que vous voulez enregistrer toutes les données du jeu dans un énorme fichier ressources. Imaginons que vous devez charger quelques données de cet énorme fichier de ressources et c'est à ce moment la que DefineVirtualFile() joue un rôle. Le paramètre 1 lie le nom du fichier qui serà la source du fichier virtuel. Les paramètres 2 et 3 définissent alors l'emplacement du fichier vituel à l'intérieur de file$. Le fichier virtuel à créer sera localisé dans le fichier file$ à partir d'une position offset+size. Le paramètre 4 spécifie finalement le nom du fichier pour le fichier virtuel. La seule chose qui est importante ici est l'extension du fichier parce qu'elle donne à Hollywood une info sur le type du fichier virtuel. Ainsi, vous devriez vous assurer que vous définissez correctement l'extension du fichier. Le nom n'est pas l'identification du type, mais l'extension du fichier devrait être utile parce que tous les fichiers ne peuvent être facilement recensé par leur en-tête (par exemple, les fichiers MP3 sont difficile à recenser). DefineVirtualFile() renvoie une chaîne décrivant le fichier virtuel. Vous pouvez lié cette chaîne à toutes les commandes Hollywood qui acceptent un nom de fichier. @{b}INPUTS@{ub} file$ - fichier source dont les données du fichier virtuel seront écrites offset - position de début du fichier virtuel à l'intérieur de file$ size - longueur en octets du fichier virtuel à l'intérieur de file$ name$ - le nom et l'extension du fichier virtuel (voir ci-dessus) @{b}RESULTATS@{ub} virtfile$ - chaîne de caractères décrivant le fichier virtuel @{b}EXEMPLE@{ub} vf$ = DefineVirvousalFile("huge_resource.dat", 100000, 32768, "image.png") LoadBrush(1, vf$, {LoadAlpha = True}) Le code ci-dessus définit un fichier virtuel à l'intérieur du fichier "huge_resource.dat". Le fichier virtuel est de la taille de 32768 octets et démarre à la position 100000 à l'intérieur du fichier "huge_resource.dat". Le fichier virtuel est une image au format png. Après avoir décrit le fichier virtuel, l'image sera chargée grce à un simple appel avec LoadBrush(). @ENDNODE @NODE WriteTable "Guide Hollywood" @{b}NOM@{ub} WriteTable -- écrire un tableau dans un fichier (V4.0) @{b}SYNOPSIS@{ub} WriteTable(id, table[, txtmode]) @{b}FONCTION@{ub} Cette commande écrit un tableau Hollywood dans un fichier spécifié par id à la position du curseur du fichier actuel que vous pouvez modifier par l'utilisation de la commande @{"Seek()" LINK Seek}. Vous pouvez charger les tableaux sauvegardés dans d'autres projets par l'utilisation de la commande @{"ReadTable()" LINK ReadTable}. L'argument optionnel txtmode spécifie si ou non le tableau sera écrit dans le fichier en tant que données binaires ou comme texte. Ce dernier est utile pour insérer des tableaux Hollywood dans des fichiers texte compréhensibles pour l'utilisateur, pour le moment en fichiers XML. Cette commande est entièrement récursive. Votre tableau peut contenir autant de sous-tableaux que vous avez besoin. De plus, le tableau peut également contenir des fonctions Hollywood. Voir l'exemple ci-dessou. @{b}INPUTS@{ub} id - fichier destination table - tableau à écrire dans le fichier txtmode - optionnel: TRUE pour écrire le tableau en texte compréhensible pour l'utilisateur ou FALSE pour écrire en données binaires ordinaires (défauts à FALSE) @{b}EXEMPLE@{ub} mytable = {1, 2, 3, 4, 5, "Hello World", x = 100, y = 150, subtable = {10, 9, 8, 7}, mulfunc = FONCTION(a, b) Return(a*b) EndFunction } OpenFile(1, "table.bin", #MODE_WRITE) WriteTable(1, mytable) CloseFile(1) OpenFile(1, "table.bin", #MODE_READ) newtable = ReadTable(1) CloseFile(1) Print(newtable[0], newtable[5], newtable.x, newtable.y, newtable.subtable[0], newtable.mulfunc(9, 9)) Le code ci-dessus écrit un tableau mytable au fichier "table.bin". Ensuite, il ouvre le fichier " table.bin " de nouveau et affiche le tableau dans Hollywood. Le tableau importé sera enregistré dans la variable newtable. En conclusion, nous accéderons au nouveau tableau importé et il affichera certaines de ses données a l'écran. Le résultat de Le code ci-dessus sera "1 Hello World 100 150 10 81". @ENDNODE @NODE ReadTable "Guide Hollywood" @{b}NOM@{ub} ReadTable -- lire un tableau à partir d'un fichier (V4.0) @{b}SYNOPSIS@{ub} table = ReadTable(id) @{b}FONCTION@{ub} Cette commande lit un tableau Hollywood à partir du fichier spécifié par id et le retourne. La lecture commence à partir de la position du curseur du fichier actuel que vous pouvez modifier en utilisant la commande @{"Seek()" LINK Seek}. Le tableau doit avoir été sauvé dans un fichier par la commande @{"WriteTable()" LINK WriteTable}. @{b}INPUTS@{ub} id - fichier à lire @{b}RESULTATS@{ub} table - le tableau affiché à partir du fichier @{b}EXEMPLE@{ub} voir @{"WriteTable()" LINK WriteTable} @ENDNODE @NODE V6LibDOSFunctions "Guide Hollywood" @{b}Bibliothèque DOS@{ub} @{"@FILE " LINK atFILE } ouvrir un fichier pour un usage ultérieur @{"ChangeDirectory() " LINK ChangeDirectory } changer le répertoire courant @{"CloseDirectory() " LINK CloseDirectory } fermer un répertoire ouvert (V4.0) @{"CloseFile() " LINK CloseFile } fermer un fichier ouvert @{"CompressFile() " LINK CompressFile } compresser un fichier (V4.0) @{"CopyFile() " LINK CopyFile } copier un fichier ou un répertoire (V2.0) @{"CRC32() " LINK CRC32 } calcule de contrôle 32 bits d'un fichier (V2.0) @{"DecompressFile() " LINK DecompressFile } décompresser un fichier (V4.0) @{"DefineVirtualFile() " LINK DefineVirtualFile } définir un fichier virtuel à l'intérieur d'un fichier réel (V4.0) @{"DeleteFile() " LINK DeleteFile } effacer un fichier ou un répertoire @{"Eof() " LINK Eof } retourner une valeur si la fin du fichier est atteinte @{"Excecute() " LINK Execute } exécuter un fichier de manière synchrone @{"Exists() " LINK Exists } vérifier si le fichier spécifié existe @{"FileLength() " LINK FileLength } obtenir la taille d'un fichier ouvert (V3.0) @{"FilePart() " LINK FilePart } renvoyer le nom d'un fichier à partir d'un chemin @{"FilePos() " LINK FilePos } retourner la position du curseur du fichier (V2.0) @{"FileSize() " LINK FileSize } retourner la taille d'un fichier spécifié @{"FlushFile() " LINK FlushFile } vider toutes les mémoires tampons en instance (V2.5) @{"FullPath() " LINK FullPath } combiner répertoire et fichier dans un chemin spécifié (V2.0) @{"GetFileAttributes() " LINK GetFileAttributes } obtenir les attributs d'un fichier ou d'un répertoire (V3.0) @{"GetTempFileName() " LINK GetTempFileName } retourner le nom d'un fichier temporaire (V3.0) @{"GetVolumeInfo() " LINK GetVolumeInfo } obtenir les informations sur la capacité d'un volume @{"GetVolumeName() " LINK GetVolumeName } obtenir le nom d'un volume @{"IsDirectory() " LINK IsDirectory } vérifier le fichier ou le répertoire (V2.0) @{"MakeDirectory() " LINK MakeDirectory } Créer un nouveau répertoire (V1.5) @{"MatchPattern() " LINK MatchPattern } vérifier si un élément correspond avec une chaîne (V2.0) @{"NextDirectoryEntry() " LINK NextDirectoryEntry} obtenir la prochaine entrée à partir d'un répertoire ouvert (V4.0) @{"OpenDirectory() " LINK OpenDirectory } ouvrir un répertoire pour examination (V4.0) @{"OpenFile() " LINK OpenFile } ouvrir un fichier pour le lire et y écrire @{"PathPart() " LINK PathPart } extraire un chemin @{"ReadChr() " LINK ReadChr } lire un caractère provenant d'un fichier spécifié @{"ReadDirectory() " LINK ReadDirectory } Lire un répertoire dans un choix de chaîne @{"ReadFloat() " LINK ReadFloat } Lire un chiffre à virgule à partir d'un fichier (V2.0) @{"ReadFunction() " LINK ReadFunction } lire une fonction à partir d'un fichier (V4.0) @{"ReadInt() " LINK ReadInt } lire un nombre entier à partir d'un fichier (V2.0) @{"ReadLine() " LINK ReadLine } lire une ligne du spécifié fichier @{"ReadShort() " LINK ReadShort } lire un nombre court à partir d'un fichier (V2.0) @{"ReadString() " LINK ReadString } Lire des octets à partir d'un fichier @{"ReadTable() " LINK ReadTable } lire un tableau à partir d'un fichier (V4.0) @{"Rename() " LINK Rename } renommer un fichier ou un répertoire (V2.0) @{"Run() " LINK Run } exécuter un fichier de manière asynchrone @{"Seek() " LINK Seek } positionner le curseur du fichier sur une nouvelle position @{"SetFileAttributes() " LINK SetFileAttributes } activer les attributs d'un fichier ou d'un répertoire (V3.0) @{"SetIOMode() " LINK SetIOMode } commuter les E/S entre mis en mémoire tampon et sans mémoire tampon (V2.5) @{"WriteChr() " LINK WriteChr } écrire un caractère dans un fichier @{"WriteFloat() " LINK WriteFloat } écrire un nombre à virgule dans un fichier (V2.0) @{"WriteFunction() " LINK WriteFunction } écrire une fonction dans un fichier (V4.0) @{"WriteInt() " LINK WriteInt } écrire un nombre entier dans un fichier (V2.0) @{"WriteLine() " LINK WriteLine } écrire une nouvelle ligne dans un fichier @{"WriteShort() " LINK WriteShort } écrire un nombre court dans un fichier (V2.0) @{"WriteString() " LINK WriteString } écrire des octets dans un fichier @{"WriteTable() " LINK WriteTable } écrire un tableau dans un fichier (V4.0) @ENDNODE @NODE Sub "Guide Hollywood" @{b}NOM@{ub} Sub -- effectuer une soustraction @{b}SYNOPSIS@{ub} result=Sub(value1,value2) @{b}FONCTION@{ub} Soustrait value2 de value1 et renvoie le result à la variable result. @{b}INPUTS@{ub} value1 - valeur de base value2 - valeur à soustraire @{b}RESULTATS@{ub} result - résultat de la soustraction @{b}EXEMPLE@{ub} a=1 a=Sub(a,1) Print(a) Le code ci-dessus affichera " 0 " à l'écran. @ENDNODE @NODE Mul "Guide Hollywood" @{b}NOM@{ub} Mul -- effectuer une multiplication @{b}SYNOPSIS@{ub} result=Mul(value1,value2) @{b}FONCTION@{ub} Multiplie value1 par value2 et renvoie le résultat. @{b}INPUTS@{ub} value1 - valeur de source value2 - multiplicateur @{b}RESULTATS@{ub} result - résultat de la multiplication @{b}EXEMPLE@{ub} a=5 a=Mul(a,5) Print(a) Ceci affichera " 25 " à l'écran. @ENDNODE @NODE Div "Guide Hollywood" @{b}NOM@{ub} Div -- effectuer une division @{b}SYNOPSIS@{ub} result=Div(value1,value2) @{b}FONCTION@{ub} Divise value1 par le facteur value2. @{b}INPUTS@{ub} value1 - numérateur value2 - dénominateur @{b}RESULTATS@{ub} result - résultat de la division @{b}EXEMPLE@{ub} a=16 Div(a,4) Print(a) Ceci affichera " 4 " à l'écran. @ENDNODE @NODE Add "Guide Hollywood" @{b}NOM@{ub} Add -- effectuer une addition @{b}SYNOPSIS@{ub} result=Add(value1,value2) @{b}FONCTION@{ub} Ajoute le nombre value2 au nombre value1. @{b}INPUTS@{ub} value1 - valeur de base value2 - nombre à ajouter @{b}RESULTATS@{ub} result - résultat de l'addition @{b}EXEMPLE@{ub} a=99 a=Add(a,1) Print(a) Ceci affichera " 100 " à l'écran. @ENDNODE @NODE Rnd "Guide Hollywood" @{b}NOM@{ub} Rnd -- générer un nombre aléatoire @{b}SYNOPSIS@{ub} result=Rnd(range) @{b}FONCTION@{ub} Génére un nombre aléatoire qui peut être de n'importe quelle chiffre de 0 à range-1. @{b}INPUTS@{ub} range - définit la limite pour des nombres; tous les nombres retournés seront plus petits que range @{b}RESULTATS@{ub} result - un nombre aléatoire @{b}EXEMPLE@{ub} num=Rnd(49) Bien, nous ne pouvons pas deviner quelle valeur numérique nous allons recevoir. Nous pouvons seulement affirmer que cette valeur numérique ne sera pas plus grande que 48 et pas plus petit que 0. @ENDNODE @NODE Cos "Guide Hollywood" @{b}NOM@{ub} Cos -- Calculer le cosinus (V1.5) @{b}SYNOPSIS@{ub} result=Cos (x) @{b}FONCTION@{ub} Calcule le cosinus de l'angle x. @{b}INPUTS@{ub} x - angle en radians @{b}RESULTATS@{ub} result - cosinus de x @ENDNODE @NODE Sin "Guide Hollywood" @{b}NOM@{ub} Sin-- calculer le sinus (V1.5) @{b}SYNOPSIS@{ub} result=Sin(x) @{b}FONCTION@{ub} Calcule le sinus de l'angle x. @{b}INPUTS@{ub} x - angle en radians @{b}RESULTATS@{ub} result - sinus de x @ENDNODE @NODE Tan "Guide Hollywood" @{b}NOM@{ub} Tan -- calculer la tangente (V1.5) @{b}SYNOPSIS@{ub} result=Tan(x) @{b}FONCTION@{ub} Calcule la tangente de l'angle x. @{b}INPUTS@{ub} x - angle en radians @{b}RESULTATS@{ub} result - tangente de x @ENDNODE @NODE Wrap "Guide Hollywood" @{b}NOM@{ub} Wrap -- obtenir une valeurs d'enveloppe (V1.5) @{b}SYNOPSIS@{ub} result=Wrap(x,low,high) @{b}FONCTION@{ub} Wrap définie le résultat de l'expression de x si x est supérieur ou égal à high, ou moins que low. Si x est plus petit que low, alors la valeur sera retourné par cette formule x-low+high. Si x est supérieur ou égal à high, alors x-high+low sera retourné. @{b}INPUTS@{ub} x - valeur source low - valeur basse high - valeur haute @{b}RESULTATS@{ub} result - résultat de la commande @ENDNODE @NODE Abs "Guide Hollywood" @{b}NOM@{ub} ABS -- obtenir une valeur absolue (V1.5) @{b}SYNOPSIS@{ub} result = Abs(val) @{b}FONCTION@{ub} Cette commande renvoie la valeur absolue de la valeur val demandée par la commande. @{b}INPUTS@{ub} val - valeur source @{b}RESULTATS@{ub} result - valeur absolue de val @ENDNODE @NODE Frac "Guide Hollywood" @{b}NOM@{ub} Frac -- obtenir la partie fractionnaire d'un nombre à virgule (V1.5) @{b}SYNOPSIS@{ub} result = Frac(val) @{b}FONCTION@{ub} Cette commande renvoie la partie fractionnaire de val, un nombre à virgule flottante. @{b}INPUTS@{ub} val - valeur source @{b}RESULTATS@{ub} result - partie fractionnaire de val @{b}EXEMPLE@{ub} a! = Frac(3.14156) La variable a! obtient la valeur 0.14156. @ENDNODE @NODE Int "Guide Hollywood" @{b}NOM@{ub} Int -- obtenir la partie entier d'un nombre à virgule flottante (V1.5) @{b}SYNOPSIS@{ub} result = Int(val) @{b}FONCTION@{ub} Cette commande renvoie la partie entier val, un nombre à virgule flottante. @{b}INPUTS@{ub} val - valeur source @{b}RESULTATS@{ub} result - partie de nombre entier de val @{b}EXEMPLE@{ub} a = Int(4.5) La variable a obtient la valeur 4. @ENDNODE @NODE Ld "Guide Hollywood" @{b}NOM@{ub} LD -- calculer le logarithme base 2 (V1.5) @{b}SYNOPSIS@{ub} result = Ld(val) @{b}FONCTION@{ub} Cette commande calcule et renvoie le logarithme base 2 de la valeur spécifié dans val. @{b}INPUTS@{ub} val - valeur source @{b}RESULTATS@{ub} result - logarithme base 2 de val @{b}EXEMPLE@{ub} a = Ld(8) La variable a obtient la valeur 3. @ENDNODE @NODE Ln "Guide Hollywood" @{b}NOM@{ub} Ln -- calculer le logarithme naturel ou népérien (base e) (V1.5) @{b}SYNOPSIS@{ub} result = Ln(val) @{b}FONCTION@{ub} Cette commande calcule et renvoie le logarithme naturel de la valeur spécifié dans val (utilisation de la base e). @{b}INPUTS@{ub} val - valeur source @{b}RESULTATS@{ub} result - logarithme naturel de val (ou népérien) @ENDNODE @NODE Log "Guide Hollywood" @{b}NOM@{ub} Log -- calculer le logarithme pour tout type de base (V1.5) @{b}SYNOPSIS@{ub} result = Log(val, base) @{b}FONCTION@{ub} Cette commande calcule et renvoie le logarithme pour n'importe quelle base de la valeur spécifié dans val. @{b}INPUTS@{ub} val - valeur source base - base de logarithme @{b}RESULTATS@{ub} result - logarithme de val de la base @{b}EXEMPLE@{ub} a = Log(100, 10) La variable a obtient la valeur 2. @ENDNODE @NODE Max "Guide Hollywood" @{b}NOM@{ub} Max -- obtenir la valeur la plus grande (V1.5) @{b}SYNOPSIS@{ub} result = Max(a, b, ...) @{b}FONCTION@{ub} Cette commande compare les valeurs a et b et renvoie la valeur qui est la plus grande. Nouveau dans V2.0: Vous pouvez insérer n'importe quel nombre d'arguments avec cette commande. Elle renverra toujours le plus grand d'entre eux. @{b}INPUTS@{ub} a - valeur a b - valeur b @{b}RESULTATS@{ub} result - la valeur la plus grande @{b}EXEMPLE@{ub} a = Max(9, 10) La variable a obtient la valeur 10. @ENDNODE @NODE Min "Guide Hollywood" @{b}NOM@{ub} Min -- obtenir la valeur la plus petite (V1.5) @{b}SYNOPSIS@{ub} result = Min(a, b, ...) @{b}FONCTION@{ub} Cette commande compare les valeurs a et b et renvoie la valeur qui est la plus petite. Nouveau dans V2.0: Vous pouvez insérer n'importe quel nombre d'arguments avec cette commande. Elle renverra toujours le plus petit d'entre eux @{b}INPUTS@{ub} a - valeur a b - valeur b @{b}RESULTATS@{ub} result - la valeur la plus petite @{b}EXEMPLE@{ub} a = Min(9, 10) La variable a obtient la valeur 9. @ENDNODE @NODE Mod "Guide Hollywood" @{b}NOM@{ub} Mod -- calculer le reste d'une division (V1.5) @{b}SYNOPSIS@{ub} result = Mod(a, b) @{b}FONCTION@{ub} Cette commande calcule le reste de la division a/b. @{b}INPUTS@{ub} a - numérateur b - dénominateur @{b}RESULTATS@{ub} result - reste de la division @{b}EXEMPLE@{ub} a = Mod(30, 4) La variable a obtient la valeur 2 parce que 30/4 = 7, 4x7=28 il reste 2. @ENDNODE @NODE Pow "Guide Hollywood" @{b}NOM@{ub} Pow -- calculer x exposant y (V1.5) @{b}SYNOPSIS@{ub} result = Pow(x, y) @{b}FONCTION@{ub} Cette commande calcule x exposant Y. @{b}INPUTS@{ub} X - base y - exposant @{b}RESULTATS@{ub} result - résultat de calcul @{b}EXEMPLE@{ub} a = Pow(2, 8) La variable a obtient la valeur de 256. @ENDNODE @NODE Round "Guide Hollywood" @{b}NOM@{ub} Round -- arrondir la valeur d'un nombre à virgule flottante (V1.5) @{b}SYNOPSIS@{ub} result = Round(x) @{b}FONCTION@{ub} Cette commande arrondit le nombre à virgule flottante spécifié par x et retourne le nombre entier supérieur. @{b}INPUTS@{ub} X - nombre à virgule flottante à arrondire @{b}RESULTATS@{ub} result - résultat en nombre entier @{b}EXEMPLE@{ub} a = Round(3.7) La variable a obtient la valeur de 4. @ENDNODE @NODE Shl "Guide Hollywood" @{b}NOM@{ub} Shl -- déplacer des bits vers la gauche (V1.5) @{b}SYNOPSIS@{ub} result = Shl(a, x) @{b}FONCTION@{ub} Cette commande déplace la valeur a de x bits vers la gauche, les nouveaux espaces seront mis à zéro (déplacement logique). a est converti en une variable de nombre entier non signé de 32 bits avant la commande de déplacement. @{b}INPUTS@{ub} a - valeur source x - nombre de déplacement @{b}RESULTATS@{ub} result - résultat en nombre entier @{b}EXEMPLE@{ub} a = Shl(256, 3) La variable a obtient la valeur de 2048. @ENDNODE @NODE Shr "Guide Hollywood" @{b}NOM@{ub} Shr -- déplacer des bits vers la droite (V1.5) @{b}SYNOPSIS@{ub} result = Shr(a, x) @{b}FONCTION@{ub} Cette commande déplace la valeur a de x bits vers la droite, les nouveaux espaces seront mis à zéro (déplacement logique). a est converti en une variable de nombre entier non signé de 32 bits avant la commande de déplacement. @{b}INPUTS@{ub} a - valeur source x - nombre de déplacement @{b}RESULTATS@{ub} result - résultat en nombre entier @{b}EXEMPLE@{ub} a = Shr(256, 3) La variable a obtient la valeur de 32. @ENDNODE @NODE Sqrt "Guide Hollywood" @{b}NOM@{ub} Sqrt -- calculer la racine carrée (V1.5) @{b}SYNOPSIS@{ub} result = Sqrt(x) @{b}FONCTION@{ub} Cette commande calcule et renvoie la racine carrée de x. @{b}INPUTS@{ub} x - valeur source @{b}RESULTATS@{ub} result - racine carrée de x @{b}EXEMPLE@{ub} a = Sqrt(64) La variable a obtient la valeur de 8. @ENDNODE @NODE Rt "Guide Hollywood" @{b}NOM@{ub} Rt -- calculer la racine (V1.5) @{b}SYNOPSIS@{ub} result = Rt(x, y) @{b}FONCTION@{ub} Cette commande calcule et renvoie la racine y de la valeur x. @{b}INPUTS@{ub} x - valeur source y - racine à calculer @{b}RESULTATS@{ub} result - racine y de x @{b}EXEMPLE@{ub} a = Rt(27, 3) La variable a obtient la valeur de 3. @ENDNODE @NODE RndF "Guide Hollywood" @{b}NOM@{ub} RndF -- générer aléatoirement un nombre à virgule flottante (V1.5) @{b}SYNOPSIS@{ub} result = RndF() @{b}FONCTION@{ub} Cette commande renvoie un nombre aléatoire de 0.0 à 1.0. @{b}INPUTS@{ub} aucun @{b}RESULTATS@{ub} result - un nombre à virgule flottante généré aléatoirement @{b}EXEMPLE@{ub} num! = RndF La variable num! reçoit un nombre à virgule flottante entre 0.0 et 1.0. @ENDNODE @NODE ASin "Guide Hollywood" @{b}NOM@{ub} ASin -- calculer l'arcsinus (V2.0) @{b}SYNOPSIS@{ub} result = ASin(x) @{b}FONCTION@{ub} Calcule l'arcsinus de x. @{b}INPUTS@{ub} x - valeur à qui arcsinus doit être calculé @{b}RESULTATS@{ub} result - arcsinus de x @ENDNODE @NODE ACos "Guide Hollywood" @{b}NOM@{ub} ACos -- calculer l'arccosinus (V2.0) @{b}SYNOPSIS@{ub} result = ACos(x) @{b}FONCTION@{ub} Calcule l'arccosinus de x. @{b}INPUTS@{ub} x - valeur à qui arccosinus doit être calculer @{b}RESULTATS@{ub} result - arccosinus de x @ENDNODE @NODE ATan "Guide Hollywood" @{b}NOM@{ub} ATan -- calculer l'arctangente (V2.0) @{b}SYNOPSIS@{ub} result = ATan(x) @{b}FONCTION@{ub} Calcule l'arctangente de x. @{b}INPUTS@{ub} x - valeur à qui l'arctangente doit être calculé @{b}RESULTATS@{ub} result - arctangente de x @ENDNODE @NODE ATan2 "Guide Hollywood" @{b}NOM@{ub} ATan2 -- calculer l'arctangente de y/x (V2.0) @{b}SYNOPSIS@{ub} result = ATan2(y, x) @{b}FONCTION@{ub} Calcule l'arctangente de y/x. Si x est 0, ATan2() renvois 0. @{b}INPUTS@{ub} y - dénominateur x - numérateur @{b}RESULTATS@{ub} result - arctangente de y/x @ENDNODE @NODE Ceil "Guide Hollywood" @{b}NOM@{ub} Ceil -- calculer le plafond d'une valeur (V2.0) @{b}SYNOPSIS@{ub} result = Ceil(x) @{b}FONCTION@{ub} Calcule la valeur plafond de x. La valeur plafond d'une valeur est le plus petit nombre entier qui est supérieur ou égal à lui même, par exemple la valeur plafond de 1.5 est 2, la valeur plafond de -1.5 est -1. @{b}INPUTS@{ub} x - valeur à qui le plafond doit être calculer @{b}RESULTATS@{ub} result - valeur plafond de x @ENDNODE @NODE Floor "Guide Hollywood" @{b}NOM@{ub} Floor -- calculer le plancher d'une valeur (V2.0) @{b}SYNOPSIS@{ub} result = Floor(x) @{b}FONCTION@{ub} Calcule la valeur plancher de x. La valeur plancher d'une valeur est le plus grand nombre entier qui est inférieur ou égal à lui même, par exemple la valeur plancher pour 1.5 est 1, la valeur planchée pour -1.5 est - 2. @{b}INPUTS@{ub} x - valeur à qui le plancher doit être prévu @{b}RESULTATS@{ub} result - valeur plancher de x @ENDNODE @NODE Exp "Guide Hollywood" @{b}NOM@{ub} Exp -- calculer l'exponentiel d'une valeur (V2.0) @{b}SYNOPSIS@{ub} result = Exp(x) @{b}FONCTION@{ub} Calcule la valeur exponentielle du nombre spécifié dans x (e ^ x). @{b}INPUTS@{ub} x - valeur dont l'exponentiel est être calculé @{b}RESULTATS@{ub} result - exponentiel de x @ENDNODE @NODE Deg "Guide Hollywood" @{b}NOM@{ub} Degré -- convertir des radians en degrés (V2.0) @{b}SYNOPSIS@{ub} result = Deg(x) @{b}FONCTION@{ub} Convertit les radians spécifiés dans x en degrés. @{b}INPUTS@{ub} x - valeur en radian qui doit être convertie en degrés @{b}RESULTATS@{ub} result - x en degré @ENDNODE @NODE Rad "Guide Hollywood" @{b}NOM@{ub} Rad -- convertir des degrés en radians (V2.0) @{b}SYNOPSIS@{ub} result = Rad(x) @{b}FONCTION@{ub} Convertit les degrés spécifiés dans x en radians. @{b}INPUTS@{ub} x - valeur en degré qui doit être convertie en radians @{b}RESULTATS@{ub} result - x en radians @ENDNODE @NODE Sgn "Guide Hollywood" @{b}NOM@{ub} Sgn -- renvoyer le signe d'une valeur (V2.0) @{b}SYNOPSIS@{ub} sign = Sgn(x) @{b}FONCTION@{ub} Renvoie le signe de la valeur x. Si x est inférieur à 0, alors -1 est retourné. Si x est supérieur à 0, alors 1 est retourné. Si x est égal à 0, 0 est retourné. @{b}INPUTS@{ub} x - valeur à examiner @{b}RESULTATS@{ub} sign - signe de x @ENDNODE @NODE Limit "Guide Hollywood" @{b}NOM@{ub} Limit -- définir une fourchette pour un nombre (V2.0) @{b}SYNOPSIS@{ub} n = Limit(x, low, high) @{b}FONCTION@{ub} Limite une fourchette pour la valeur x. Si x est supérieur ou égal à low et inférieur ou égal à high, la valeur de x est retournée. Si x est moins que low, alors low est retourné. Si x est plus grand que high, alors high est retourné. Cette commande s'assure que la valeur de x reste dans les limites indiquées par low et high. @{b}INPUTS@{ub} x - valeur à examiner @{b}RESULTATS@{ub} n - résultat de la fonction de limite @ENDNODE @NODE BitClear "Guide Hollywood" @{b}NOM@{ub} BitClear -- initialiser une valeur binaire (V2.0) @{b}SYNOPSIS@{ub} n = BitClear(x, b) @{b}FONCTION@{ub} Initialise le nombre de bits b dans la valeur x. @{b}INPUTS@{ub} x - valeur source b - bit à initialiser (0-31) @{b}RESULTATS@{ub} n - valeur libérée @{b}EXEMPLE@{ub} Print(BinStr(BitClear(Val("%11111111"), 2))) Le code ci-dessus initialise le bit N°2 dans la valeur %11111111 qui a comme résultat la valeur %11111011. @ENDNODE @NODE BitComplement "Guide Hollywood" @{b}NOM@{ub} BitComplement -- inverser une valeur binaire (V2.0) @{b}SYNOPSIS@{ub} n = BitComplement(x) @{b}FONCTION@{ub} Cette commande inverse tous les bits dans la valeur x. Chaque valeur est traité comme nombre entier de 32 bits. @{b}INPUTS@{ub} x - valeur source @{b}RESULTATS@{ub} n - valeur inversée @{b}EXEMPLE@{ub} Print(BinStr(BitComplement(Val("%11110000")))) Le code ci-dessus inverse la valeur %11110000 et retourne %11111111111111111111111100001111. @ENDNODE @NODE BitSet "Guide Hollywood" @{b}NOM@{ub} BitSet -- régler un bit (V2.0) @{b}SYNOPSIS@{ub} n = BitSet(x, b) @{b}FONCTION@{ub} Régle le nombre de bits b dans la valeur x et renvoie le résultat. @{b}INPUTS@{ub} x - valeur source b - bit à régler @{b}RESULTATS@{ub} n - résultat de la fonction @{b}EXEMPLE@{ub} Print(BinStr(BitSet(Val("%10111111"), 6))) Le code ci-dessus active le bit 6 dans la valeur %10111111 et renvoient le résultat qui est %11111111. @ENDNODE @NODE BitTest "Guide Hollywood" @{b}NOM@{ub} BitTest -- vérifier si un bit est activé (V2.0) @{b}SYNOPSIS@{ub} bool = BitTest(x, b) @{b}FONCTION@{ub} Tests si le numéro de bits b est activé dans la valeur x et renvoi TRUE si c'est le cas, sinon FALSE. @{b}INPUTS@{ub} x - valeur source b - bit à tester @{b}RESULTATS@{ub} bool - TRUE si le bit est activé, sinon FALSE @{b}EXEMPLE@{ub} Print(BitTest(Val("%10101111"), 4)) Renvoie FALSE parce que le numéro de bits 4 n'est pas activé dans %10101111. @ENDNODE @NODE BitXor "Guide Hollywood" @{b}NOM@{ub} BitXor -- compare 2 valeur binaire avec la fonction logique xor (V2.0) @{b}SYNOPSIS@{ub} r = BitXor(a, b) @{b}FONCTION@{ub} Effectue une opération XOR bit à bit sur les 2 valeurs spécifiées et retourne le résultat. L'opération de ou-exclusif activera chaque bit de la valeur qui en résulte que si le bit correspondant est activé dans l'une des valeurs sources. Si le bit est activé dans les 2 valeurs sources, il ne sera pas activé dans la valeur résultante @{b}INPUTS@{ub} a - valeur 1 source b - valeur 2 source @{b}RESULTATS@{ub} r - résultat de la fonction logique xor @{b}EXEMPLE@{ub} Print(BinStr(BitXor(Val("%11010001"), Val("%10110010"))) Exécute le ou-exclusif sur les valeurs %11010001 et %10110010 qui a comme résultat la valeur %01100011. @ENDNODE @NODE Sar "Guide Hollywood" @{b}NOM@{ub} Sar -- déplacer les bits vers la droite (V3.0) @{b}SYNOPSIS@{ub} result = Sar(a, x) @{b}FONCTION@{ub} Cette commande déplace la valeur a de x bit vers la droite et rempli les vides avec le MSB de a (décalage arithmétique). a est converti en variable de nombre entier de 32 bits signée avant la commande de déplacement. @{b}INPUTS@{ub} a - valeur source x - nombre de bit à déplacer @{b}RESULTATS@{ub} result - résultat en nombre entier @{b}EXEMPLE@{ub} a = Sar(-256, 3) La variable a obtient la valeur de -32. @ENDNODE @NODE Rol "Guide Hollywood" @{b}NOM@{ub} Rol -- rotation des bits par la gauche (V3.0) @{b}SYNOPSIS@{ub} result = Rol(a, x[, length]) @{b}FONCTION@{ub} Cette commande tourne les bits de la valeur a vers la gauche de x bits. La rotation de bit signifie que les bits tourne à l'intérieur de a, les bits déplacés hors du côté gauche sont immédiatement ajoutés au côté droit. L'argument optionnel vous permet de spécifier la longueur de la fonction de rotation. Par défaut, c'est un #INTEGER qui signifie que a sera considéré comme des valeurs entières de 32 bits. Si vous voulez faire une rotation de 16 bits ou de 8 bits, vous devez utiliser respectivement le #SHORT et le #BYTE. @{b}INPUTS@{ub} a - valeur source x - nombre de bits à tourner lenght - optionnel: longueur de morceau pour cette commande (par défauts : #INTEGER qui signifie la rotation de 32 bits); utiliser #SHORT pour la rotation de 16 bits et le #BYTE pour la rotation de 8 bits @{b}RESULTATS@{ub} result - valeur tournée @{b}EXEMPLE@{ub} r = Rol(Val("%10011110"), 4, #BYTE) Print(BinStr(r, #BYTE)) Le code ci-dessus tourne le nombre binaire %10011110 de 4 bits vers la gauche et affiche le résultat qui est %11101001. @ENDNODE @NODE Ror "Guide Hollywood" @{b}NOM@{ub} Ror -- rotation des bits par la droite(V3.0) @{b}SYNOPSIS@{ub} result = Ror(a, x[, length]) @{b}FONCTION@{ub} Cette commande tourne les bits de la valeur a vers la droite de x bits. La rotation de bit signifie que les bits tourne à l'intérieur de a, les bits déplacés hors du côté droit sont immédiatement ajoutés au côté gauche. L'argument optionnel vous permet de spécifier la longueur de la fonction de rotation. Par défaut, c'est un #INTEGER qui signifie que a sera considéré comme des valeurs entières de 32 bits. Si vous voulez faire une rotation de 16 bits ou de 8 bits, vous devez utiliser respectivement le #SHORT et le #BYTE. @{b}INPUTS@{ub} a - valeur source x - nombre de bits à tourner lenght - optionnel: longueur de morceau pour cette commande (par défauts: #INTEGER qui signifie la rotation de 32 bits); utiliser #SHORT pour la rotation de 16 bits et le #BYTE pour la rotation de 8 bits @{b}RESULTATS@{ub} result - valeur tournée @{b}EXEMPLE@{ub} r = Ror(Val("%10011110"), 2, #BYTE) Print(BinStr(r, #BYTE)) Le code ci-dessus tourne le nombre binaire %10011110 2 bits vers la gauche et affiche le résultat qui est %10100111. @ENDNODE @NODE Cast "Guide Hollywood" @{b}NOM@{ub} Cast -- convertir un nombre en un nouveau type signé/non signé (V3.0) @{b}SYNOPSIS@{ub} result = Cast(val, sign, type) @{b}FONCTION@{ub} Cette commande peut être utilisé pour convertir une valeur dans un type différent. Ce n'est normalement pas impossible pour Hollywood puisque le langage ne connaît qu'un seul type de variable numérique (tous les nombres dans Hollywood sont stockés en tant que valeurs à virgules flottantes de 64-bit signées ; Hollywood ne fait pas de différence entre l'octet, le nombre court, le nombre entier, et les nombres à virgule). Ainsi, tous ce que vous recevez comme " résultat " n'est pas réellement une variable du type que vous avez convertie, mais il restera juste dans les limites du type de variable que vous avez spécifié. Cependant, Cette commande peut devenir maniable quand il s'agit d'effectuer des conversions entre signées et non signé. Vous pouvez avoir besoin de connaître quel nombre vous obtenez quand vous voulez convertir 41234 en une valeur courte signée. Vous pouvez utiliser cette fonction pour effectuer se genre d'opération. Cast reçoit trois arguments: Le premier argument est la valeur qui sera convertie, le deuxième argument spécifie si oui ou non vous voulez une valeur signée et doit être TRUE ( = converti à signé ) ou FALSE ( = converti à non signé). Le dernier argument spécifie finalement sous qu'elle type la valeur sera convertie. Ceci peut être #INTEGER (de 32 bits), #SHORT (de 16 bits) ou #BYTE (de 8 bits). @{b}INPUTS@{ub} val - valeur source à convertir sign - TRUE (Conversion signé) ou FALSE (conversion non signé) type - type de conversion pour la valeur (#INTEGER, #SHORT ou #BYTE) @{b}RESULTATS@{ub} result - résultat de la fonction de conversion @{b}EXEMPLE@{ub} Print(Cast(41234, TRUE, #SHORT)) Le code ci-dessus convertit le nombre 41234 en une valeur (de 16 bits) courte signée et affiche le résultat qui est - (2^16-41234) = -24302. @ENDNODE @NODE V6LibMath "Guide Hollywood" @{b}Bibliothèque MATHEMATIQUE@{ub} @{"Abs() " LINK Abs } obtenir une valeur absolue (V1.5) @{"ACos() " LINK ACos } calculer l'arccosinus (V2.0) @{"Add() " LINK Add } effectuer une addition @{"ASin() " LINK ASin } calculer l'arcsinus (V2.0) @{"ATan() " LINK ATan } calculer l'arctangente (V2.0) @{"ATan2() " LINK ATan2 } calculer l'arctangente de y/x (V2.0) @{"BitClear() " LINK BitClear } initialiser une valeur binaire (V2.0) @{"BitComplement() " LINK BitComplement} inverser une valeur binaire (V2.0) @{"BitSet() " LINK BitSet } régler un bit (V2.0) @{"BitTest() " LINK BitTest } vérifier si un bit est activé (V2.0) @{"BitXor() " LINK BitXor } compare 2 valeur binaire avec la fonction logique xor (V2.0) @{"Cast() " LINK Cast } convertir un nombre pour un nouveau type signé/non signé (V3.0) @{"Ceil() " LINK Ceil } calculer le plafond d'une valeur (V2.0) @{"Cos() " LINK Cos } calculer le cosinus (V1.5) @{"Deg() " LINK Deg } convertir des radians en degrés (V2.0) @{"Div() " LINK Div } effectuer une division @{"Exp() " LINK Exp } calculer l'exponentiel d'une valeur (V2.0) @{"Floor() " LINK Floor } calculer le plancher d'une valeur (V2.0) @{"Frac() " LINK Frac } obtenir la partie fractionnaire d'un nombre à virgule flottante (V1.5) @{"Int() " LINK Int } obtenir la partie entier d'un nombre à virgule flottante (V1.5) @{"Ld() " LINK Ld } calculer le logarithme base 2 (V1.5) @{"Limit() " LINK Limit } définir une fourchette pour un nombre (V2.0) @{"Ln() " LINK Ln } calculer le logarithme naturel ou népérien (base e) (V1.5) @{"Log() " LINK Log } calculer le logarithme pour tout type de base (V1.5) @{"Max() " LINK Max } obtenir la valeur la plus grande (V1.5) @{"Min() " LINK Min } obtenir la valeur la plus petite (V1.5) @{"Mod() " LINK Mod } calculer le reste d'une division (V1.5) @{"Mul() " LINK Mul } effectuer une multiplication @{"Pow() " LINK Pow } calculer x exposant y (V1.5) @{"Rad() " LINK Rad } convertir des degrés en radians (V2.0) @{"Rnd() " LINK Rnd } générer un nombre aléatoire @{"RndF() " LINK RndF } générer aléatoirement un nombre à virgule flottante (V1.5) @{"Rol() " LINK Rol } rotation des bits par la gauche (V3.0) @{"Ror() " LINK Ror } rotation des bits par la droite (V3.0) @{"Round() " LINK Round } arrondir la valeur d'un nombre à virgule flottante (V1.5) @{"Rt() " LINK Rt } calculer la racine (V1.5) @{"Sar() " LINK Sar } déplacer les bits vers la droite (V3.0) @{"Sgn() " LINK Sgn } renvoyer le signe d'une valeur (V2.0) @{"Shl() " LINK Shl } déplacer des bits vers la gauche (V1.5) @{"Shr() " LINK Shr } déplacer des bits vers la droite (V1.5) @{"Sin() " LINK Sin } calculer le sinus (V1.5) @{"Sqrt() " LINK Sqrt } calculer la racine carrée (V1.5) @{"Sub() " LINK Sub } effectuer une soustraction @{"Tan() " LINK Tan } calculer la tangente (V1.5) @{"Wrap() " LINK Wrap } obtenir une valeurs d'enveloppe (V1.5) @ENDNODE @NODE PlayModule "Guide Hollywood" @{b}NOM@{ub} PlayModule -- commencer à jouer un module de musique / @{b}OBSOLETE@{ub} @{b}SYNOPSIS@{ub} PlayModule(number) @{b}NOTE IMPORTANTE@{ub} Cette commande est OBSOLETE. Utiliser @{"PlayMusic()" LINK PlayMusic}. @{b}FONCTION@{ub} Commence à jouer le module de musique identifié par number. Ce module de musique doit être déclaré avec le mot clé @{"%MODULE(number)" LINK MODULE} ou être chargé avec @{"LoadModule()" LINK LoadModule}. Si il y a déjà un module de musique qui est joué, il sera arrété. @{b}INPUTS@{ub} number - numéro du module de musique à jouer @{b}EXEMPLE@{ub} LoadModule(1,"StardustMemories.mod") PlayModule(1) @ENDNODE @NODE PauseModule "Guide Hollywood" @{b}NOM@{ub} PauseModule -- mettre en pause le module joué / @{B}OBSOLETE@{UB} @{b}SYNOPSIS@{ub} PauseModule() @{b}NOTE IMPORTANTE@{ub} Cette commande est @{b}OBSOLETE@{ub}. Utiliser @{"PauseMusic()" LINK PauseMusic}. @{b}FONCTION@{ub} Cette commande effectue une pause sur le module joué. Il peut être repris avec @{"ResumeModule()" LINK ResumeModule}. @{b}INPUTS@{ub} aucun @ENDNODE @NODE ResumeModule "Guide Hollywood" @{b}NOM@{ub} ResumeModule -- reprendre le module en pause / @{B}OBSOLETE@{UB} @{b}SYNOPSIS@{ub} ResumeModule() @{b}NOTE IMPORTANTE@{ub} Cette commande est @{b}OBSOLETE@{ub}. Utiliser @{"ResumeMusic()" LINK ResumeMusic}. @{b}FONCTION@{ub} Cette commande reprend le module après une pause. Il peut être mis en pause avec @{"PauseModule()" LINK PauseModule}. @{b}INPUTS@{ub} aucun @ENDNODE @NODE StopModule "Guide Hollywood" @{b}NOM@{ub} StopModule -- arrêter le module joué / @{B}OBSOLETE@{UB} @{b}SYNOPSIS@{ub} StopModule() @{b}IMPORTANT NOTE@{ub} Cette commande est @{b}OBSOLETE@{ub}. Utiliser @{"StopMusic()" LINK StopMusic}. @{b}FONCTION@{ub} Arrête le module qui est joué et libère toute les sorties audio utilisée @{b}INPUTS@{ub} aucun @ENDNODE @NODE PlaySubsong "Guide Hollywood" @{b}NOM@{ub} PlaySubsong -- commencer à jouer une musique d'un module @{b}SYNOPSIS@{ub} PlaySubsong(number) @{b}FONCTION@{ub} Commence à  jouer la musique du module joué. Vous devez utiliser @{"PlayModule()" LINK PlayModule} avant d'utiliser cette commande. @{b}INPUTS@{ub} number - numéro de la musique à  jouer @{b}EXEMPLE@{ub} PlayModule(1) PlaySubsong(5) Le code ci-dessus commence à jouer le module numéro 1 et saute à la musique numéro 5. @ENDNODE @NODE WaitPatternPosition "Guide Hollywood" @{b}NOM@{ub} WaitPatternPosition -- arrêter le programme jusqu'a ce que le module arrive à la position du pattern défini @{b}SYNOPSIS@{ub} WaitPatternPosition(pos) @{b}FONCTION@{ub} Cette commande arrête le déroulement du programme jusqu'a se que le module joué atteigne la position du pattern spécifié par pos. Vous devez utiliser @{"PlayModule()" LINK PlayModule} avant d'utiliser cette commande. C'est utile pour caler vos applications avec la musique. @{b}INPUTS@{ub} pos - position du pattern à attendre @{b}EXEMPLE@{ub} PlayModule(1) WaitPatternPosition(63) Le code ci-dessus commence à jouer le module numéro 1 et attend alors qu'il arrive à l'extrémité du premier pattern. @ENDNODE @NODE WaitSongPosition "Guide Hollywood" @{b}NOM@{ub} WaitSongPosition -- arrêter le programme jusqu'a ce que le module arrive à la position demandé de la musique @{b}SYNOPSIS@{ub} WaitSongPosition(pos) @{b}FONCTION@{ub} Cette commande arrête le déroulement du programme jusqu'a se que le module joué atteigne la musique (song) spécifié par pos. Vous devez utiliser @{"PlayModule()" LINK PlayModule} avant d'utiliser cette commande. C'est utile pour caler vos applications avec la musique. @{b}INPUTS@{ub} pos - position de la musique à attendre @{b}EXEMPLE@{ub} PlayModule(1) WaitSongPosition(2) Le code ci-dessus commence à jouer le module numéro 1 et attend alors qu'il arrive à la musique (song) numéro 2 @ENDNODE @NODE LoadModule "Guide Hollywood" @{b}NOM@{ub} LoadModule -- charger un module / @{B}OBSOLETE@{UB} @{b}SYNOPSIS@{ub} LoadModule(id,filename$) @{b}NOTE IMPORTANTE@{ub} Cette commande est @{b}OBSOLETE@{ub}. Utiliser @{"OpenMusic()" LINK OpenMusic}. @{b}FONCTION@{ub} Cette commande charge le module spécifié par filename$ dans la mémoire et lui donne l'identification id. Le module doit être dans le format Protracker. @{b}INPUTS@{ub} id - identificateur pour le module filename$ - fichier à charger @{b}EXEMPLE@{ub} voir le mot clé @{"%MODULE" LINK MODULE} @ENDNODE @NODE FreeModule "Guide Hollywood" @{b}NOM@{ub} FreeModule -- libérer un module / @{B}OBSOLETE@{UB} @{b}SYNOPSIS@{ub} FreeModule(id) @{b}NOTE IMPORTANTE@{ub} Cette commande est @{b}OBSOLETE@{ub}. Utiliser @{"CloseMusic()" LINK CloseMusic}. @{b}FONCTION@{ub} Cette commande libère la mémoire du module spécifié par id. Ceci n'est pas nécessaire puisque Hollywood libère toute la mémoire quand il est quitté. Cependant, si vous manquez de mémoire et que vous voulez libérer l'échantillon par vous-même, utiliser cette commande. @{b}INPUTS@{ub} id - identificateur pour le module @ENDNODE @NODE PlaySample "Guide Hollywood" @{b}NOM@{ub} PlaySample -- commencer à jouer un échantillon @{b}SYNOPSIS@{ub} PlaySample(number, ...) PlaySample(number[, times], ...) PlaySample(number[, table], ...) (V2.0) @{b}FONCTION@{ub} Commence à  jouer l'échantillon spécifié par number. Vous pouvez charger des échantillons avec la commande @{"LoadSample()" LINK LoadSample} ou la commande préprocesseur @{"@SAMPLE" LINK atSAMPLE} (l'échantillon sera alors préchargé). L'argument optionnel times spécifie combien de fois l'échantillon sera joué. La valeur 1 signifie que l'échantillon sera joué une fois. Si vous voulez que l'échantillon boucle indéfiniment, régler times à 0. Depuis Hollywood 2.0, vous pouvez également utiliser un tableau comme second argument qui définit des paramètres pour la lecture d'échantillon. Le tableau (table) peut contenir les indicateurs suivants: Volume : Réglage du volume désiré de lecture. Cet indicateur peut s'échelonner de 0 à 64. Si il n'est pas spécifié, le volume par défaut de l'échantillon sera utilisé (vous pouvez modifier le volume de défaut d'un échantillon en utilisant SetVolume()). Pitch : Réglage du pitch désiré de lecture. Cette valeur doit être écrite en hertz. Si il n'est pas spécifié, le pitch par défaut de l'échantillon sera utilisé ( vous pouvez modifier le pitch par défaut d'un échantillon en utilisant SetPitch() ). Time : Cet indicateur peut être utilisé pour définir combien de temps l'échantillon sera joué. Hollywood bouclera l'échantillon jusqu'à  ce que le temps indiqué soit écoulé. Le temps doit être spécifié en millisecondes. Nouveau dans Hollywood 2.0, c'est la possibilité de jouer immédiatement plusieurs échantillons avec la commande PlaySample(). Répéter simplement la liste d'arguments autant de fois que vous le voulez et PlaySample() jouera tous les échantillons spécifié en même temps, parfaitement synchronisé. Noter que pour chaque échantillon supplémentaire, il y a également un argument optionnel supplémentaire, où chaque argument spécifie le nombre de fois que l'échantillon sera joué ou un tableau qui contient d'autres arguments pour la lecture d'échantillon. Voir ci-dessus pour toutes les possibilités. @{b}INPUTS@{ub} number - numéro de l'échantillon à jouer ... - arguments optionnels arguments optionnels supportés : times - nombre de fois que l'échantillon sera joué (valeur par défauts: 1). Régler à 0 pour boucle infini table - un tableau qui contient des paramètres de lecture pour l'échantillon (V2.0) ... - la liste d'arguments peut être répétée autant de fois que désirée. PlaySample() jouera tous les échantillons en même temps si vous en indiquez plus d'un. @{b}EXEMPLE@{ub} PlaySample(1) Le code ci-dessus commence à  jouer l'échantillon 1. L'échantillon ne sera pas bouclé. -------------------- PlaySample(1, {time = 10000}) Le code ci-dessus joue l'échantillon 1 pendant exactement 10 secondes (= 10000 millisecondes). -------------------- PlaySample(1, 2, 2, 4, 3, {time=5000}) Le code ci-dessus joue l'échantillon 1 deux fois, l'échantillon 2 quatre fois et l'échantillon 3 est joués pendant 5 secondes. Chacun des trois échantillons est commencé en même temps. @ENDNODE @NODE StopSample "Guide Hollywood" @{b}NOM@{ub} StopSample -- cesser de jouer un échantillon @{b}SYNOPSIS@{ub} StopSample(id) @{b}FONCTION@{ub} Cesse de jouer l'échantillon spécifié par id et libère toutes les sorties audio alloué pour cet échantillon. @{b}INPUTS@{ub} id - identification de l'échantillon à arrêter @ENDNODE @NODE LoadSample "Guide Hollywood" @{b}NOM@{ub} LoadSample -- charger un échantillon @{b}SYNOPSIS@{ub} [id] = LoadSample(id, filename$) @{b}FONCTION@{ub} Cette commande charge l'échantillon spécifié par filename$ dans la mémoire et affecte l'identification id. Si vous indiquez @{"Nil" LINK V6PrgTypeNil} comme id, LoadSample() choisira automatiquement une id vide et la renverra. Les formats d'échantillons qui peuvent être chargés par cette commande dépendent du système d'exploitation sur lequel Hollywood est exécuté, excepté les formats d'échantillons RIFF WAVE, IFF 8SVX, et IFF16SV. Ceux-ci fonctionnent sur toutes les plates-formes mais ils ne doivent pas être compressé. Cette commande est également disponible avec le préprocesseur : Utiliser @{"@SAMPLE" LINK atSAMPLE} pour précharger des échantillons. Noter que cette commande charge les données complètes de l'échantillon dans la mémoire. Si vous planifier de jouer de longs échantillons, utiliser plutôt @{"OpenMusic()" LINK OpenMusic} qui enregistre en mémoire tampon de petites parties des données sonore dans la mémoire. @{b}INPUTS@{ub} id - identificateur pour l'échantillon ou @{"Nil" LINK V6PrgTypeNil} pour @{"la sélection automatique d'Id" LINK AutoIDSelect} filename$ - fichier à charger @{b}RESULTATS@{ub} id - optionnel: identificateur de l'échantillon; sera seulement retourné quand vous obtenez @{"Nil" LINK V6PrgTypeNil} comme argument 1. (voir ci-dessus) @{b}EXEMPLE@{ub} LoadSample(1,"dh0:Sound/Samples/WahWah.8svx") PlaySample(1) WaitSampleEnd(1) FreeSample(1) Le code ci-dessus charge l'échantillon "dh0:Sound/Samples/WahWah.8svx" et le joue puis attend qu'il termine et libère la mémoire. @ENDNODE @NODE FreeSample "Guide Hollywood" @{b}NOM@{ub} FreeSample -- libérer un échantillon @{b}SYNOPSIS@{ub} FreeSample(id) @{b}FONCTION@{ub} Cette commande libère la mémoire de l'échantillon spécifié par id mais ceci n'est normalement pas nécessaire puisque Hollywood libère toute la mémoire quand il est quitté. Cependant, si vous manquez de mémoire et que vous voulez libérer l'échantillon par vous-même, utiliser cette commande. @{b}INPUTS@{ub} id - identificateur pour l'échantillon @{b}EXEMPLE@{ub} voir @{"LoadSample()" LINK LoadSample} @ENDNODE @NODE WaitSampleEnd "Guide Hollywood" @{b}NOM@{ub} WaitSampleEnd -- arrêter jusqu'à  ce que la lecture de l'échantillon soit terminé @{b}SYNOPSIS@{ub} WaitSampleEnd (id) @{b}FONCTION@{ub} Cette commande arrête le déroulement du programme jusqu'à ce que l'échantillon spécifié par id soit terminé de joué. Après cela, l'exécution de votre script est continué. Si vous devez faire quelque chose tandis que votre échantillon joue, utilisez la commande @{"IsSamplePlaying()" LINK IsSamplePlaying} conjointement avec une boucle. @{b}INPUTS@{ub} id - identificateur pour un échantillon qui est joué @{b}EXEMPLE@{ub} voir @{"LoadSample()" LINK LoadSample} @ENDNODE @NODE IsSamplePlaying "Guide Hollywood" @{b}NOM@{ub} IsSamplePlaying -- vérifier si un échantillon est joué @{b}SYNOPSIS@{ub} playing=IsSamplePlaying(id) @{b}FONCTION@{ub} Cette commande contrôle si l'échantillon spécifié par id est joué et renvois TRUE si oui, FALSE si non. @{b}INPUTS@{ub} id - identificateur pour un échantillon @{b}RESULTATS@{ub} playing - TRUE si l'échantillon spécifié par id est joué, FALSE si non @{b}EXEMPLE@{ub} LoadSample(1,"dh0:Sound/Samples/ChurchOrgan.8svx") PlaySample(1) Repeat Wait(2) Until IsSamplePlaying(1) = False FreeSample(1) Le code ci-dessus charge l'échantillon "dh0:Sound/Samples/ChurchOrgan.8svx" et le joue, puis attend alors pour terminer. Ensuite, l'échantillon est libéré. Si vous voulez effectuer la même opération que cité ci-dessus, il est plus facile que vous utilisiez la commande @{"WaitSampleEnd()" LINK WaitSampleEnd}. Mais si vous voulez effectuer autre choses pendant que l'échantillon est joué vous devrez le faire de cette façon (en utilisant @{"IsSamplePlaying()" LINK IsSamplePlaying} et une boucle). @ENDNODE @NODE SetVolume "Guide Hollywood" @{b}NOM@{ub} SetVolume -- modifier le volume d'un échantillon @{b}SYNOPSIS@{ub} SetVolume(id,volume) @{b}FONCTION@{ub} Cette commande modifie le volume de l'échantillon spécifié par id. Si l'échantillon est joué, le volume sera modifié à la volé (en temps réel) et pourrée être utile pour les fades sonores etc... Depuis Hollywood 2.0, le volume peut également contenir une chaîne contenant des spécifications en pourcentage, par exemple "50%". @{b}INPUTS@{ub} id - identificateur d'un échantillon volume - nouveau volume pour l'échantillon (gamme: 0=silence, jusqu'au volume 64=maximum ou spécification en %) @{b}EXEMPLE@{ub} LoadSample(1,"dh0:Sound/Samples/GroovyLoop.8svx") PlaySample(1) Wait(100) For k = 64 To 0 Step -1 SetVolume(1,vol) Next Le code ci-dessus charge l'échantillon "dh0:Sound/Samples/GroovyLoop.8svx" et le joue, puis attent 2 secondes et effectue une diminution du volume @ENDNODE @NODE SetPitch "Guide Hollywood" @{b}NOM@{ub} SetPitch -- modifier le pitch d'un échantillon @{b}SYNOPSIS@{ub} SetPitch(id,pitch) @{b}FONCTION@{ub} Cette commande modifie le pitch de l'échantillon spécifié par id. Si l'échantillon est joué, le pitch sera modifié à la volé (en temps réel). Cette commande peut être utilisé pour effectuer quelques effets sonore sympathique. Le pitch est spécifié en hertz. @{b}INPUTS@{ub} id - identificateur d'un échantillon pitch - nouveau pitch pour l'échantillon en hertz @ENDNODE @NODE IsSample "Guide Hollywood" @{b}NOM@{ub} IsSample -- déterminer si un échantillon est dans un format compatible @{b}SYNOPSIS@{ub} ret=IsSample(file$) @{b}FONCTION@{ub} Cette commande vérifiera si le fichier spécifiait file$ est dans un format d'échantillon compatible. Si il l'est, Cette fonction renverra TRUE, si non FALSE. Si Cette fonction renvoie TRUE, vous pourrez charger l'échantillon en utilisant @{"LoadSample()" LINK LoadSample}. @{b}INPUTS@{ub} file$ - fichier à  vérifier @{b}RESULTATS@{ub} ret - TRUE si l'échantillon est dans un format compatible, sinon FALSE @ENDNODE @NODE IsModule "Guide Hollywood" @{b}NOM@{ub} IsModule -- déterminer si un module est dans un format compatible / @{B}OBSOLETE@{UB} @{b}SYNOPSIS@{ub} ret=IsModule(file$) @{b}NOTE IMPORTANTE@{ub} Cette commande est @{b}OBSOLETE@{ub}. Utiliser @{"IsMusic()" LINK IsMusic} @{b}FONCTION@{ub} Cette commande vérifie si le fichier spécifiait par file$ est dans un format de module compatible. Si il l'est, Cette fonction renverra TRUE, sinon FALSE. Si cette commande renvoie TRUE, vous pouvez charger le module en utilisant @{"LoadModule()" LINK LoadModule}. @{b}INPUTS@{ub} file$ - fichier à  vérifier @{b}RESULTATS@{ub} ret - TRUE si le module est dans un format compatible, si non FALSE @ENDNODE @NODE IsSound "Guide Hollywood" @{b}NOM@{ub} IsSound -- déterminer si Hollywood peut utiliser la sortie audio @{b}SYNOPSIS@{ub} ret=IsSound() @{b}FONCTION@{ub} Cette commande teste si Hollywood peut utiliser la sortie audio. Vous pouvez utiliser cette commande si votre application ne peut pas fonctionner sans son. Normalement si Hollywood ne peut pas utiliser les sorties audio, tout le code audio sera ignoré et le script sera continué. Si vous ne voulez pas qu'hollywood ignore la partie audio, utiliser IsSound() pour déterminer si les sorties audio peuvent être utilisé. @{b}INPUTS@{ub} aucun @{b}RESULTAT@{ub} ret - TRUE si le son peut être joué, si non FALSE @{b}EXEMPLE@{ub} If IsSound() = False SystemRequest("My App","Sorry, sound is required!","OK") End EndIf Le code ci-dessus teste s'il peut utiliser la sortie audio et stop le script avec un message d'erreur si ce n'est pas possible. @ENDNODE @NODE SetMasterVolume "Guide Hollywood" @{b}NOM@{ub} SetMasterVolume -- régler le volume principal (V1.5) @{b}SYNOPSIS@{ub} SetMasterVolume(vol) @{b}FONCTION@{ub} Note : Cette commande est quelque peu obsolète et pourrait être retiré. Utiliser @{"SetVolume()" LINK SetVolume} pour les échantillons et @{"SetMusicVolume()" LINK SetMusicVolume} pour les modules de musique Protracker. Cette commande règle le volume principal à la valeur spécifiée par vol. En utilisant cette commande vous pouvez vous rendre compte que le volume sonore diminue ou augmente des sorties audios. Depuis Hollywood 2.0, le ratio peut également contenir une chaîne qui contient des spécifications en pourcentage, par exemple "50%". @{b}INPUTS@{ub} vol - nouveau volume principal (gamme 0 à 64 ou chaîne en %) @{b}EXEMPLE@{ub} For k = 64 To 0 Step -5 SetMasterVolume(k) Next Le code ci-dessus diminue le volume de tous les sons en modifiant le volume principal. @ENDNODE @NODE SetPanning "Guide Hollywood" @{b}NOM@{ub} SetPanning -- régler la balance de l'échantillon (V1.9) @{b}SYNOPSIS@{ub} SetPanning(id, pan) @{b}FONCTION@{ub} Cette commande vous permet de spécifier où l'échantillon identifié par id sera joué. La variable pan s'échelonner de 0 à  255, où 0 signifie que l'échantillon sera seulement joué par le haut-parleur gauche et 255 signifie que l'échantillon sera seulement joué par le haut-parleur droit. Si vous voulez jouer l'échantillon dans les deux haut-parleurs avec le même volume indiquer 128 qui est également la valeur par défaut. Vous pouvez également indiquer les constantes spéciales #LEFT, #CENTER, et #RIGHT ce qui correspondent respectivement à 0, à 128, et à 255. Si l'échantillon est joué, la balance sera modifié à la volé (en temps réel) se qui peut être utiliser pour créer quelques effets sympathique. @{b}INPUTS@{ub} id - identification de l'échantillon à  utiliser pan - nouvel valeur de balance (s'échelonne de 0 à  255) @{b}EXEMPLE@{ub} SetPanning(1, 255) PlaySample(1) Le code ci-dessus va jouer l'échantillon seulement par le haut parleur droit. @ENDNODE @NODE GetSongPosition "Guide Hollywood" @{b}NOM@{ub} GetSongPosition -- obtenir la position actuelle d'une musique (V1.9) @{b}SYNOPSIS@{ub} p = GetSongPosition() @{b}FONCTION@{ub} Cette commande renvoie la position de la musique d'un module protracker joué et si aucun module n'est joué, -1 est retourné. Vous pouvez caler votre script en musique avec cette commande. Vous pouvez également utiliser @{"WaitSongPosition()" LINK WaitSongPosition} qui arrête le déroulement du programme jusqu'à se qu'une certaine position de musique soit atteinte. @{b}INPUTS@{ub} aucun @{b}RESULTATS@{ub} p - position de la musique joué ou -1 @ENDNODE @NODE GetPatternPosition "Guide Hollywood" @{b}NOM@{ub} GetPatternPosition -- obtenir la position d'un pattern (V1.9) @{b}SYNOPSIS@{ub} p = GetPatternPosition() @{b}FONCTION@{ub} Cette commande renvoie la position de pattern du Module Protracker joué. Si aucun module n'est joue, -1 est retourné. Vous pouvez caler votre script en musique avec cette commande. Vous pouvez également utiliser @{"WaitPatternPosition()" LINK WaitPatternPosition} qui arrête le déroulement du programme jusqu'à se qu'une certaine position de pattern soit atteinte. @{b}INPUTS@{ub} aucun @{b}RESULTATS@{ub} p - position du pattern joué ou -1 @ENDNODE @NODE CreateSample "Guide Hollywood" @{b}NOM@{ub} CreateSample -- créer un échantillon (V2.0) @{b}SYNOPSIS@{ub} CreateSample(id, wavedata, pitch) @{b}FONCTION@{ub} Cette commande peut être utilisé pour créer un nouvel échantillon provenant de données brutes spécifié comme un tableau dans l'argument wavedata. L'échantillon sera ajouté à la liste d'échantillon Hollywood et vous pourrez l'utilisé grce à id. Vous devez également spécifier la fréquence désirée de lecture pour cet échantillon dans l'argument pitch. L'application actuelle s'attend à ce que vous obteniez des données brutes avec comme indication: son mono 8 bits signées s'échelonnant de -128 à 127. Le tableau que vous obtenez dans wavedata doit contenir au moins 1000 échantillons. Si vous utilisez moins d'échantillons, la lecture en mode boucle deviendra très gourmande en ressources CPU. Même si votre échantillon n'a seulement que 32 formes d'ondes différentes, vous devrez les enchaîner jusqu'à ce que votre tableau ait au moins 1000 échantillons. @{b}INPUTS@{ub} id - identificateur pour le nouvel échantillon wavedata - tableau contenant la forme d'onde pitch - fréquence désirée de lecture pour l'échantillon @{b}EXEMPLE@{ub} smpdata = {} slen = 32 For k = 0 To 30 For i = 0 To (slen\\2)-1 smpdata[k*slen+i] = -128 smpdata[k*slen+i+(slen\\2)] = 127 Next Next CreateSample(1, smpdata, 6982) PlaySample(1) Le code ci-dessus produit un simple bip. @ENDNODE @NODE OpenMusic "Guide Hollywood" @{b}NOM@{ub} OpenMusic -- ouvrir une musique (V2.0) @{b}SYNOPSIS@{ub} [id] = OpenMusic(id, filename$) @{b}FONCTION@{ub} Cette commande ouvre un fichier de musique spécifié par filename$ et lui assigne id. Si vous obtenez @{"Nil" LINK V6PrgTypeNil} comme id, OpenMusic() choisira une id vide et la renverra. Le fichier spécifié dans filename$ sera ouvert et préparé à la lecture. Les formats supportés de musique sont le MPEG (le mp3) et Protracker (mod). Noter que cette commande ne charge pas nécessairement le fichier complétement dans la mémoire. Si vous ouvrez un fichier MP3 avec OpenMusic() il initialisera juste la musique puisque les MP3 sont toujours lu directement à partir de la source. Cette commande est également disponible avec le préprocesseur: Utiliser @{"@MUSIC" LINK atMUSIC} pour précharger des musiques. Depuis Hollywood 2.5, Cette fonction peut également ouvrir des fichiers: IFF 8SVX, IFF 16SV et RIFF WAVE, et quelques autres formats de streaming selon sur qu'elle plate-forme fonctionne Hollywood. Hollywood supporte les deux type d'échantillonnage 8 et 16 bits aussi bien que les modes mono et stéréo. Veuillez noter que les échantillons compressés ne sont pas encore supportés. Utiliser OpenMusic() seulement pour de grand échantillons ( > 128 kilo-octets) parce qu'ils seront lus à  partir du disque. Les échantillons doivent être chargés avec @{"LoadSample()" LINK LoadSample} et être joués avec @{"PlaySample()" LINK PlaySample}. @{b}INPUTS@{ub} id - identificateur pour la musique ou @{"Nil" LINK V6PrgTypeNil} pour @{"la sélection automatique d'Id" LINK AutoIDSelect} filename$ - fichier à charger @{b}RESULTATS@{ub} id - optionnel: identificateur de la musique; sera seulement retourné quand vous indiquerez @{"Nil" LINK V6PrgTypeNil} comme argument 1. (voir ci-dessus) @{b}EXEMPLE@{ub} OpenMusic(1, "dh0:Turrican2_Remix.mp3") PlayMusic(1) Le code ci-dessus joue "dh0:Turrican2_Remix.mp3". @ENDNODE @NODE CloseMusic "Guide Hollywood" @{b}NOM@{ub} CloseMusic -- libérer une musique (V2.0) @{b}SYNOPSIS@{ub} CloseMusic(id) @{b}FONCTION@{ub} Cette commande libère la mémoire occupée par la musique spécifié par id et ferme le fichier. Ce n'est normalement pas nécessaire puisque Hollywood libère toute la mémoire quand il est quitté. Cependant, si vous n'avez plus de mémoire et que vous voulez libérer la musique par vous-même, utiliser cette commande. @{b}INPUTS@{ub} id - identificateur pour que la musique se ferme @ENDNODE @NODE IsMusic "Guide Hollywood" @{b}NOM@{ub} IsMusic -- déterminer si un fichier est dans un format de musique compatible (V2.0) @{b}SYNOPSIS@{ub} ret, fmt$ = IsMusic(file$) @{b}FONCTION@{ub} Cette commande vérifiera si le fichier spécifié dans file$ est compatible au format de musique. Si il l'est, Cette fonction renverra TRUE dans la première valeur de renvoi, sinon FALSE. Si Cette fonction renvoie TRUE, vous pourrez ouvrir la musique en utilisant @{"OpenMusic()" LINK OpenMusic}. La deuxième valeur de renvoi est une chaîne contenant le format de musique du fichier. Ce sera "Unknown", "MPEG Audio" ou "Protracker". @{b}INPUTS@{ub} file$ - fichier à  vérifier @{b}RESULTATS@{ub} ret - TRUE si la musique est dans un format compatible, si non FALSE fmt$ - format du fichier musique; si il est "Unknown", "MPEG Audio" ou "Protracker" @ENDNODE @NODE PauseMusic "Guide Hollywood" @{b}NOM@{ub} PauseMusic -- mettre en pause une musique joué (V2.0) @{b}SYNOPSIS@{ub} PauseMusic(id) @{b}FONCTION@{ub} Cette commande effectue une pause de la musique avec l'identification id. Cette musique doit être joué quand vous appelez cette commande. Vous pouvez reprendre la lecture en utilisant la commande @{"ResumeMusic()" LINK ResumeMusic}. @{b}INPUTS@{ub} id- identificateur de la musique à mettre en pause @ENDNODE @NODE ResumeMusic "Guide Hollywood" @{b}NOM@{ub} ResumeMusic -- reprendre une musique après une pause (V2.0) @{b}SYNOPSIS@{ub} ResumeMusic(id) @{b}FONCTION@{ub} Cette commande reprend la lecture de la musique à  qui on a effectué une pause avec l'identification id. Vous pouvez faire une pause sur une musique avec @{"PauseMusic()" LINK PauseMusic}. @{b}INPUTS@{ub} id - identificateur de la musique à reprendre @ENDNODE @NODE SeekMusic "Guide Hollywood" @{b}NOM@{ub} SeekMusic -- recherche une position dans une musique (V2.0) @{b}SYNOPSIS@{ub} SeekMusic(id, pos) @{b}FONCTION@{ub} Vous pouvez utiliser cette commande pour rechercher une position dans la musique spécifié par id. La musique ne doit pas être jouer. Si la musique est joué et que vous appelez SeekMusic(), il effectuera un saut immédiatement à la position spécifié. La position est spécifiée en millisecondes. Ainsi, si vous voulez sauter à la position 3:24, vous devrez indiquer la valeur 204000 parce que 3*60*1000 + 24*1000 = 204000. Veuillez noter que cette commande ne fonctionne pas avec les modules Protracker. @{b}INPUTS@{ub} id - identificateur de la musique à utiliser pos - nouvelle position pour la musique @ENDNODE @NODE PlayMusic "Guide Hollywood" @{b}NOM@{ub} PlayMusic -- commencer la lecture d'une musique (V2.0) @{b}SYNOPSIS@{ub} PlayMusic(id[, times]) @{b}FONCTION@{ub} Cette commande commence la lecture de la musique spécifié par id. Cette musique doit avoir été ouverte avec @{"@MUSIC" LINK atMUSIC} ou la commande préprocesseur @{"OpenMusic()" LINK OpenMusic}. Veuillez noter qu'avec l'application actuelle, qu'une seule musique peut être jouée à la fois. Ainsi, si une musique est joué et que vous appelez cette commande, cette musique sera arrêté avant que la lecture commence. Le deuxième argument est optionnel et également nouveau depuis Hollywood 2.5. Il spécifie combien de fois la musique sera joué. Cet argument est par défaut réglé sur 1 ce qui signifie que la musique est seulement jouée une fois. Si vous voulez que votre musique boucle indéfiniment, il faudra indiquer 0 comme deuxième argument. @{b}INPUTS@{ub} id - identificateur de la musique à commencer times - optionnels : spécifie combien de fois cette musique sera joué (V2.5) (défauts à  1) @{b}EXEMPLE@{ub} voir @{"OpenMusic()" LINK OpenMusic} @ENDNODE @NODE SetMusicVolume "Guide Hollywood" @{b}NOM@{ub} SetMusicVolume -- modifier le volume d'une musique (V2.0) @{b}SYNOPSIS@{ub} SetMusicVolume(id, volume) @{b}FONCTION@{ub} Cette commande modifie le volume de la musique spécifié par id. Si la musique est joué, le volume sera modifiée à la volé (en temps réel) et pourrée être utilisé pour créer un fade sonore etc... Depuis Hollywood 2.0, le volume peut également contenir de chaîne contenant des spécification en pourcentage, par exemple "50%". @{b}INPUTS@{ub} id - identificateur de la musique volume - nouveau volume pour la musique (gamme : 0=silence jusqu'au volume 64=maximum ou spécifications en pourcentage %) @ENDNODE @NODE StopMusic "Guide Hollywood" @{b}NOM@{ub} StopMusic -- arrêter une musique joué (V2.0) @{b}SYNOPSIS@{ub} StopMusic(id) @{b}FONCTION@{ub} Cette commande arrête la musique spécifié par id. La musique doit être jouer. @{b}INPUTS@{ub} id - identificateur de la musique à arrêter @ENDNODE @NODE V6LibSoundSample "Hollywood Guide" @{b}Fonction échantillon (sample)@{ub} @{"@SAMPLE " LINK atSAMPLE } Précharger un échantillon @{"CreateSample() " LINK CreateSample } créer un échantillon (V2.0) @{"FreeSample() " LINK FreeSample } libérer un échantillon @{"IsSample() " LINK IsSample } déterminer si un échantillon est dans un format compatible @{"IsSamplePlaying() " LINK IsSamplePlaying} vérifier si un échantillon est joué @{"LoadSample() " LINK LoadSample } charger un échantillon @{"PlaySample() " LINK PlaySample } commencer à  jouer un échantillon @{"SetPanning() " LINK SetPanning } régler la balance de l'échantillon (V1.9) @{"SetPitch() " LINK SetPitch } modifier le pitch d'un échantillon @{"SetVolume() " LINK SetVolume } modifier le volume d'un échantillon @{"StopSample() " LINK StopSample } cesser de jouer un échantillon @{"WaitSampleEnd() " LINK WaitSampleEnd } arrêter jusqu'à  ce que la lecture de l'échantillon soit terminé @ENDNODE @NODE V6LibSoundMusic "Guide Hollywood" @{b}Fonction musique@{ub} @{"@MUSIC " LINK atMUSIC } Pré charger une musique @{"CloseMusic() " LINK CloseMusic } libérer une musique (V2.0) @{"IsMusic() " LINK IsMusic } déterminer si un fichier est dans un format de musique compatible (V2.0) @{"OpenMusic() " LINK OpenMusic } ouvrir une musique (V2.0) @{"PauseMusic() " LINK PauseMusic } mettre en pause une musique joué (V2.0) @{"PlayMusic() " LINK PlayMusic } commencer la lecture d'une musique (V2.0) @{"ResumeMusic() " LINK ResumeMusic } reprendre une musique après une pause (V2.0) @{"SeekMusic() " LINK SeekMusic } recherche une position dans une musique (V2.0) @{"SetMusicVolume() " LINK SetMusicVolume} modifier le volume d'une musique (V2.0) @{"StopMusic() " LINK StopMusic } arrêter une musique joué (V2.0) Les commandes suivantes peuvent seulement être utilisé quand @{"PlayMusic()" LINK PlayMusic} joue un Module Protracker : @{"GetPatternPosition() " LINK GetPatternPosition } obtenir la position d'un pattern (V1.9) @{"GetSongPosition() " LINK GetSongPosition } obtenir la position actuelle d'une musique (V1.9) @{"PlaySubsong() " LINK PlaySubsong } commencer à  jouer une musique d'un module @{"WaitPatternPosition() " LINK WaitPatternPosition} arrêter le programme jusqu'a ce que le module arrive à la position du pattern défini @{"WaitSongPosition() " LINK WaitSongPosition } arrêter le programme jusqu'a ce que le module arrive à la position de la musique Les comandes suivantes ont été utilisées par Hollywood 1.x pour jouer les modules Protracker. Elles peuvent encore être utilisés puisque Hollywood 2.0 les émules. Pour les nouveaux script, cependant, vous devriez améliorer l'utilisation des nouvelles fonctions de music comme indiqué ci-dessus. @{"FreeModule() " LINK FreeModule } libérer un module @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"IsModule() " LINK IsModule } déterminer si un module est dans un format compatible @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"LoadModule() " LINK LoadModule } charger un module @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"PauseModule() " LINK PauseModule } mettre en pause le module joué @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"PlayModule() " LINK PlayModule } commencer à  jouer un module de musique @{APEN 4}@{b}OBSOLETE@{ub}@{APEN 1} @{"ResumeModule() " LINK ResumeModule} reprendre le module en pause @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @{"StopModule() " LINK StopModule } arrêter le module joué @{APEN 4}@{B}OBSOLETE@{UB}@{APEN 1} @ENDNODE @NODE V6LibSoundMisc "Guide Hollywood" @{b}Fonction sonore diverse@{ub} @{"IsSound() " LINK IsSound } déterminer si Hollywood peut utiliser la sortie audio @{"SetMasterVolume() " LINK SetMasterVolume} régler le volume principal (V1.5) @ENDNODE @NODE V6LibSound "Guide Hollywood" @{b}Bibliothèque SONORE@{ub} La bibliothèque sonore d'Hollywood vous offre un ensemble de commandes qui fonctionne avec les échantillons et les modules de Protracker. @{"Fonctions échantillon (Sample) " LINK V6LibSoundSample} @{"Fonctions musique " LINK V6LibSoundMusic} @{"Fonctions sonores diverses " LINK V6LibSoundMisc} @ENDNODE @NODE BGPICIntroduction "Guide Hollywood" @{b}Introduction sur les images de fonds d'écrans@{ub} Le concept des images de fond est très simple: L'image de fond qui est actuellement affiché est votre écran. Votre écran est votre "zone de travail", c'est la zone que vous pouvez utiliser pour afficher tous se que vous voulez. Cette zone vous est entièrement dédié et vous pouvez l'utiliser comme vous le désirez. Les autres parties de la fenêtre (par exemple les bords de fenêtre) ne peuvent pas être modifié par votre application. Exemple: Votre image de fond est une image d'une résolution de 320x256. votre écran sera également de la résolution de 320x256 pixels indépendemment des réglages de la fenêtre utilisateur. Si vous changez la taille de l'écran, en utilisant @{"ChangeDisplaySize()" LINK ChangeDisplaySize} par exemple, votre image de fond sera redimensionnée pour qu'elle soit adapté aux nouvelles dimensions, puisque comme dit auparavant, les tailles d'écran sont toujours identique à la taille de l'image de fond utilisé. Si votre fenêtre est redimensionnable, alors l'utilisateur peut également ajuster vos tailles d'écran. Si il le fait, Hollywood lancerà la commande interne @{"ChangeDisplaySize()" LINK ChangeDisplaySize} pour ajuster les nouvelles dimensions. Si vous choisissez d'afficher une nouvelle image de fond en utilisant par exemple la commande @{"DisplayBGPic()" LINK DisplayBGPic} , et que les dimensions de la nouvelle image de fond est diffèrente des dimension de votre image de fond utilisé, alors votre écran sera également redimensionné pour adapter les nouvelles dimensions. Au démarrage, Hollywood affichera l'image de fond avec comme numéro le 1. Si vous ne déclarez pas une image de fond avec le numéro 1 en utilisant la commande préprocesseur @{"@BGPIC" LINK atBGPIC}, cela ouvrira un écran d'une résolution de 640x480 avec un écran noir. Si vous voulez une autre résolution que le 640x480, vous devez utiliser la commande préprocesseur @{"@DISPLAY" LINK atDISPLAY}. @ENDNODE @NODE ChangeDisplaySize "Guide Hollywood" @{b}NOM@{ub} ChangeDisplaySize -- changer les dimensions de l'écran @{b}SYNOPSIS@{ub} ChangeDisplaySize(width, height[, args]) @{b}FONCTION@{ub} Cette commande modifie les dimensions de l'écran aux dimensions spécifié. L'image de fond utilisé sera redimensionnée pour s'adapter aux nouvelles dimensions. Par conséquent vous pouvez également utiliser cette commande pour le redimensionnement d'image de fond. Nouveau dans la v2.0: Vous pouvez utiliser #KEEPASPRAT en tant que la largeur ou hauteur. Hollywood calculerà la taille en prenant compte du ratio d'aspect de l'écran automatiquement. Depuis Hollywood 2.0, la largeur et la hauteur peuvent également être une chaîne contenant des spécifications en pourcentage, par exemple "50%". Nouveau avec Hollywood 4.0: Vous pouvez utiliser un tableau dans le troisième argument optionnel pour spécifier d'autres options. Actuellement, le tableau peut contenir les indicateurs suivants : X : spécifie la nouvelle position de x pour l'écran (défauts : #CENTER) Y : spécifie la nouvelle position de y pour l'écran (défauts : #CENTER) Régulier : spécifie si oui ou non les images seront redimensionnées en utilisant l'anti-crénelage (défauts : FALSE) @{b}INPUTS@{ub} width - nouvelle largeur désirée pour l'écran height - nouvelle hauteur désirée pour l'écran args - optionnels : d'autres options de configuration (V4.0) @{b}EXEMPLE@{ub} ChangeDisplaySize(320, 240) Ceci change la taille de l'écran en 320x240. @ENDNODE @NODE CreateGradientBGPic "Guide Hollywood" @{b}NOM@{ub} CreateGradientBGPic -- créer une nouvelle image de fond avec un dégradé (V2.0) @{b}DEJA CONNU COMME@{ub} CreateRainbowBGPic (V1.0 - V1.9) @{b}SYNOPSIS@{ub} CreateGradientBGPic(id, type, startcolor, endcolor[,width, height, angle]) @{b}FONCTION@{ub} Cette commande crééra une nouvelle image de fond pour vous et elle généra un beau dégradé sur cette image avec les couleurs de début et de fin que vous pouvez spécifier. type spécifie le type de dégradé que vous voulez utiliser. Actuellement, #LINEAR est le seul type disponible. Si la largeur et la hauteur ne sont pas indiquées, les dimensions seront identiques aux dimensions de l'écran utilisé . angle vous permet de spécifier un angle de rotation (en degrés) pour le dégradé. @{b}INPUTS@{ub} id - identification pour la nouvelle image de fond type - type du dégradé ; actuellement seul #LINEAR est possible startcolor - @{"Valeur RGB " LINK RGBInfo} définit la couleur de départ endcolor - @{"Valeur RGB " LINK RGBInfo} définit la couleur de fin width - optionnel: largeur désirée pour llimage de fond (défaut : largeur de l'écran utilisé) height - optionnel: hauteur désirée pour l'imagede fond (défaut : hauteur de l'écran utilisé) angle - optionnel: angle de rotation pour le dégradé (défaut : 0) @{b}EXEMPLE@{ub} CreateGradientBGPic(2, #LINEAR, #BLACK, #BLUE) DisplayBGPic(2) Créer un dégradé longitudinal comme image de fond 2 avec une couleur allant du noir au bleu et l'affiche. @ENDNODE @NODE CreateTexturedBGPic "Guide Hollywood" @{b}NOM@{ub} CreateTexturedBGPic -- créer une nouvelle image de fond avec comme texture une brosse (brush) @{b}SYNOPSIS@{ub} CreateTexturedBGPic(id,brushid[,width,height]) @{b}FONCTION@{ub} Cette commande créée une nouvelle image de fond et elle lui donnera une comme texture une brosse spécifié par le brushid. Si la largeur et la hauteur ne sont pas indiquées, les dimensions seront identiques à l'écran utilisé. @{b}INPUTS@{ub} id - identification pour la nouvelle image de fond brushid - identification de la brosse (brush) à utiliser comme texture width - optionnel: largeur désirée pour l'image de fond (défaut : largeur de l'écran utilisé) height - optionnel: hauteur désirée pour l'image de fond (défaut : hauteur de l'écran utilisé) @{b}EXEMPLE@{ub} CreateTexturedBGPic(2,1) DisplayBGPic(2) Créé une image de fond qui aura comme texture la brosse 1 et l'affiche. @ENDNODE @NODE DisplayBGPic "Guide Hollywood" @{b}NOM@{ub} DisplayBGPic -- modifier l'image de fond @{b}SYNOPSIS@{ub} DisplayBGPic(id[, args]) @{b}FONCTION@{ub} Cette commande modifie l'image de fond par celle spécifiée par id. Si les dimensions de cette image diffèrent de l'actuelle, la taille de l'écran sera appliqué. Depuis Hollywood 4.0: Vous pouvez utiliser un tableau dans le deuxième argument optionnel pour spécifier d'autres options. Actuellement, le tableau peut contenir les indicateurs suivants : X : spécifie la nouvelle position de x pour l'écran (défauts : #CENTER) Y : spécifie la nouvelle position de y pour l'écran (défauts : #CENTER) @{b}INPUTS@{ub} id - identification de l'image de fond à afficher args - optionnel: spécifie d'autres options de configuration (V4.0) @{b}EXEMPLE@{ub} DisplayBGPic(2) Affiche l'image de fond 2 et ajuste la taille de la fenêtre si nécessaire. *** DisplayBGPic(2, {X = #RIGHT, Y = #BOTTOM}) Affiche l'image de fond en bas à droite du bureau. @ENDNODE @NODE DisplayBGPicPart "Guide Hollywood" @{b}NOM@{ub} DisplayBGPicPart -- Afficher une partie d'une image de fond @{b}SYNOPSIS@{ub} DisplayBGPicPart(id, x, y, width, height[, table]) [V4.0] DisplayBGPicPart(id, x, y, width, height[, dx, dy, objs]) [old syntax until V3.1] @{b}FONCTION@{ub} Ce commande affiche une partie de l'image de fond spécifé par id sur l'écran. La partie est définie par x, y, sa largeur (width) et sa hauteur (height). Depuis Hollywood 4.0, cette commande utilise une nouvelle syntaxe, bien que l'ancienne syntaxe soit encore supportée pour des raisons de compatibilité. Néanmoins, les nouveau scripts doivent utiliser la nouvelle syntaxe. La nouvelle syntaxe reçoit un tableau en tant qu'argument se qui vous permet de spécifier plusieurs autres options : DX : Position de la destination X pour la partie à afficher. (défauts a x spécifié comme paramètre 2) DY : Position de la destination y pour la partie à afficher. (défauts a y spécifé comme paramètre 3) Calque (layer) : Si vous le paramétré avec TRUE, les calques (au cas où des calques seraient activés) ou les images (au cas où les calques seraient désactivés) de l'image de fond seront également affichées. C'est utile si vous voulez créer une copie exacte d'une image de fond dans une brosse par exemple. Veuillez noter que si les calques sont désactivés, vous pourrez utiliser cet argument seulement si "id" spécifie l'identification d'une image de fond utilisé parce que Hollywood ne garde pas l'image de toute l'image de fond si les calques sont désactivé. @{b}INPUTS@{ub} id - identification de l'image de fond à utiliser comme source X - coin gauche Y - coin du haut width - largeur de la partie à afficher height - hauteur de la partie à afficher table - optionnel: tableau de configuration @{b}EXEMPLE@{ub} DisplayBGPicPart(2,0,0,100,100) Affiche les 100 premiers Pixel et colonnes de l'image de fond 2 sur l'écran à la position 0:0. *** width = GetAttribute(#DISPLAY, 0, #ATTRWIDTH) height = GetAttribute(#DISPLAY, 0, #ATTRHEIGHT) id = GetAttribute(#DISPLAY, 0, #ATTRBGPIC) CreateBrush(1, width, height) SelectBrush(1) DisplayBGPicPart(id, 0, 0, width, height, {Layers = TRUE}) EndSelect Ce code créé une copie du contenu de l'écran dans la brosse (brush) 1. @ENDNODE @NODE DisplayBGPicPartFX "Guide Hollywood" @{b}NOM@{ub} DisplayBGPicPartFX -- afficher une partie d'une image de fond avec une transition @{b}SYNOPSIS@{ub} DisplayBGPicPartFX(id, x, y, width, height[, table]) [V4.0] DisplayBGPicPartFX(id, x, y, width, height[, effect, speed, arg, dx, dy, objs]) [old syntax up to V3.1] @{b}FONCTION@{ub} C'est une version étendue de la commande @{"DisplayBGPicPart()" LINK DisplayBGPicPart}. Elle fait la même chose mais elle affiche la partie avec un effet de transition. Depuis Hollywood 4.0 cette commande utilise une nouvelle syntaxe avec juste un tableau comme argument optionnel. L'ancienne syntaxe est encore supportée pour des raisons de compatibilité. tableau d'argument optionnel peut être utilisé pour configurer l'effet de transition. Les options suivantes sont disponibles: Type : Spécifie l'effet souhaité pour la transition. Pour une liste de toutes les transitions disponible, regarder la documentation de la commande @{"DisplayTransitionFX()" LINK DisplayTransitionFX} (défauts : #RANDOMEFFECT) Speed : Spécifie la vitesse désirée pour la transition. Plus la valeur que vous indiquez ici sera élevé, plus la vitesse de transition sera rapide. (défauts : #NORMALSPEED) Parameter : Quelques effets de transition qui ont un paramètre supplémentaire. Ceci peut être spécifié ici. (défauts : #RANDOMPARAMETER) Async : Vous pouvez utiliser cet indicateur pour créer un objet asynchrone pour cette transition. Si vous indiquez TRUE ici, DisplayBGPicPartFX() sera immédiatement quitté, renvoyant la prise en charge d'objet asynchrone que vous pouvez alors afficher en utilisant AsyncDrawFrame(). Voir la documentation de @{"AsyncDrawFrame()" LINK AsyncDrawFrame}. DX : Position de la destination en X pour la partie à afficher. (défauts : x spécifié comme paramètre 2) Dy : Position de la destination en y pour la partie à afficher. (défauts : y spécifié comme paramètre 3) Calques : Indiquer TRUE ici si les calques de l'image de fond doivent également affichés (exige que les calques soient activés). (défauts : FALSE) @{b}INPUTS@{ub} id - identification de l'image de fond à utiliser comme source X - coin gauche y - coin en haut width - largeur de la partie à afficher height - hauteur de la partie à afficher table - optionnel: configuration d'effet de transition @{b}EXEMPLE@{ub} DisplayBGPicPartFX(2, 0, 0, 100, 100, #HSTRIPES32, 10) ; ancienne syntaxe OU DisplayBGPicPartFX(2, 0, 0, 100, 100, {Type = #HSTRIPES32, Speed = 10}) ; Nouvelle syntaxe Affiche les 100 premiers pixel et colonnes de l'image de fond 2 sur l'écran avec l'effet de transition #HSTRIPES32 avec une vitesse de 10. @ENDNODE @NODE DisplayTransitionFX "Guide Hollywood" @{b}NOM@{ub} DisplayTransitionFX -- changer l'image de fond en utilisant un effet de transition @{b}SYNOPSIS@{ub} DisplayTransitionFX(id[, table]) [V4.0] DisplayTransitionFX(id[, effect, speed, arg]) [old syntax up to V3.0] @{b}FONCTION@{ub} Cette commande affiche une nouvelle image de fond avec l'effet de transition spécifié. Une liste de tous les effets disponibles est ajoutée ci-après. Vous devez également indiquer la vitesse de transition qui peut être une des constantes spéciales de vitesse (#SLOWSPEED, #NORMALSPEED, #FASTSPEED) ou une valeur numérique choisi. La règle pour le paramètre de vitesse: plus elle est élevée et plus la valeur de transition sera rapide. Pour un effet qualité, la nouvelle image de fond doit avoir les mêmes dimensions que celle affiché précédement. Si ce n'est pas le cas, l'ancienne image de fond sera redimensionné à la taille de la nouvelle. Depuis Hollywood 4.0 cette commande utilise une nouvelle syntaxe avec juste un tableau comme argument optionnel. L'ancienne syntaxe est encore supportée pour des raisons de compatibilité. Le tableau d'argument optionnel peut être utilisé pour configurer l'effet de transition . Les options suivantes sont disponibles: Type : Spécifie l'effet souhaité pour la transition . Voir la liste indiquer ci-dessous pour les effets disponibles. (défauts : #RANDOMEFFECT) Speed : Spécifie la vitesse désirée pour la transition . Plus la valeur que vous indiquez ici sera élevé, plus la vitesse de transition sera rapide. (défauts : #NORMALSPEED) Paramètre : Quelques effets de transition qui ont un paramètre supplémentaire. Ceci peut être spécifié ici. (défauts : #RANDOMPARAMETER) Async : Vous pouvez utiliser cet indicateur pour créer un objet asynchrone pour cette transition. Si vous indiquez TRUE ici, DisplayBGPicPartFX() sera immédiatement quitté, renvoyant la prise en charge d'objet asynchrone que vous pouvez alors afficher en utilisant AsyncDrawFrame(). Voir la documentation de @{"AsyncDrawFrame()" LINK AsyncDrawFrame} * * * Les effets suivants sont actuellement disponibles: Rayure horizontales : #HSTRIPES2, #HSTRIPES4, #HSTRIPES16, #HSTRIPES32 Rayure verticales : #VSTRIPES2, #VSTRIPES8, #VSTRIPES16, #VSTRIPES32 Stores horizontaux : #HBLINDS8, #HBLINDS16, #HBLINDS32, #HBLINDS64, #HBLINDS128 Stores verticale : #VBBLINDS8, #VBLINDS16, #VBLINDS32, #VBLINDS64, #VBLINDS128 Rideau horizontal : #HOPENCURTAIN, #HCLOSECURTAIN Rideau vertical : #VOPENCURTAIN, #VCLOSECURTAIN Lignes horizontales : #HLINES, #HLINES2 Lignes verticales : #VLINES, #VLINES2 Dévoiler : #REVEALLEFT, #REVEALRIGHT, #REVEALTOP, #REVEALBOTTOM Bars : #BARS Quarts : #QUARTERS Fondu enchaîné : #CROSSFADE Disparition graduelle : #FADE ; l'argument optionnel spécifie la couleur à utiliser Mélange : #BLEND ; l'argument optionnel spécifie la couleur à utiliser pour le mélange Depuis Hollywood 1.5, il y a quelques nouveaux effets : Dans un rectangle : #RECTCENTER, #RECTNORTH, #RECTNORTHEAST, #RECTEAST #RECTSOUTHEAST, #RECTSOUTH, #RECTSOUTHWEST, #RECTWEST #RECTNORTHWEST A l'extérieur d'un rectangle : #RECTBACKCENTER, #RECTBACKNORTH, #RECTBACKNORTHEAST #RECTBACKEAST, #RECTBACKSOUTHEAST, #RECTBACKSOUTH #RECTBACKSOUTHWEST, #RECTBACKWEST, #RECTBACKNORTHWEST Défilement : #SCROLLLEFT, #SCROLLRIGHT, #SCROLLTOP, #SCROLLBOTTOM (l'argument optionnel spécifie un effet spécial pour appliquer au procédé de défilement, vous pouvez utiliser les mêmes effets ici comme avec @{"MoveBrush()" LINK MoveBrush}) Etirer : #STRETCHLEFT, #STRETCHRIGHT, #STRETCHTOP, #STRETCHBOTTOM #HSTRETCHCENTER, #VSTRETCHCENTER Zoomer : #ZOOMCENTER, #ZOOMNORTH, #ZOOMNORTHEAST, #ZOOMEAST #ZOOMSOUTHEAST, #ZOOMSOUTH, #ZOOMSOUTHWEST, #ZOOMWEST #ZOOMNORTHWEST Effet d'eau : #HFLOWTOP, #HFLOWBOTTOM, #VFLOWLEFT, #VFLOWRIGHT Porte : #HOPENGATE, #HCLOSEGATE, #VOPENGATE, #VCLOSEGATE (b) Poussées : #PUSHLEFT, #PUSHRIGHT, #PUSHTOP, #PUSHBOTTOM (b) Puzzle : #PUZZLE Diagonale : #DIAGONAL Dérouler : #ROLLTOP Papier peint : #WALLPAPERTOP Stores verticales : #VSTRIPES ; l'argument optionnel spécifie le nombre des pistes à afficher Stores horizontales : #HSTRIPES ; l'argument optionnel spécifie le nombre des stores à afficher Depuis Hollywood 1.9, il y a quelques nouveaux effets : Défilement : #SCROLLNORTHEAST, #SCROLLSOUTHEAST, #SCROLLSOUTHWEST, #SCROLLSOUTHEAST (l'argument optionnel spécifie un effet spécial pour appliquer au procédé de défilement, vous pouvez utiliser les mêmes effets ici comme avec @{"MoveBrush()" LINK MoveBrush}) Affiche dans le sens des aiguilles d'une montre : #CLOCKWIPE Zoom en forme d'étoile : #STAR Déplacement étranges : #HSTRANGEPUSH, #VSTRANGEPUSH (b) Projecteur de diapositives : #SLIDELEFT, #SLIDERIGHT, #SLIDETOP, #SLIDEBOTTOM (b) Affichage en spirale : #SPIRAL Effet croix suisse : #SWISS Quadrillage avec des rectangles : #QUADRECT Effets découpé : #HSPLIT, #VSPLIT De haut en bas : #UPNDOWN Effet carte d'enregistrement : #CARDTOP, #CARDBOTTOM (b) Zoom Sun : #SUN Ondulations de liquide : #WATER1, #WATER2, #WATER3, #WATER4 (!) Effet strudel : #STRUDEL (!) Dissoudre l'image : #DISSOLVE Zoom sur Pixel : #PIXELZOOM1 Zoom sur Pixel 2 : #PIXELZOOM2 (b) Large effets de zoom : #ZOOMIN, #ZOOMOUT (b) Effets d'écrasement : #CRUSHLEFT, #CRUSHRIGHT, #CRUSHTOP, #CRUSHBOTTOM (b) Effet feuilleté une page : #VFLIPCOIN, #VLOWFLIPCOIN, #HFLIPCOIN, #HLOWFLIPCOIN (b) Sortir l'image : #TURNDOWNTOP, #TURNDOWNBOTTOM, #TURNDOWNLEFT, #TURNDOWNRIGHT (b) Machine à écrire : #TYPEWRITER (t) [plus disponible depuis V3.1] Papier peint : #WALLPAPERLEFT (!) Déroulé : #ROLLLEFT Effet au hasard : #RANDOMEFFECT Si vous choisissez #RANDOMEFFECT, Hollywood choisira au hasard un effet parmis tous les effets disponibles. Très utile pour créer des présentations. Quand vous utilisez la version 68k de Hollywood, #RANDOMEFFECT ne choisira pas les effets gourmand automatiquement. Légende : (b) : l'effet peut seulement être utilisé avec des images de fond (o) : l'effet peut seulement être utilisé avec des objets (brosses (brush), calques (layers), etc. - mais pas d'images de fond!) (t) : l'effet peut seulement être utilisé avec des objets textes (!) : effets avec d'important calcule se qui signifie qu'il a besoin de beaucoup de ressources CPU pour le faire fonctionner avec fluidité. Vous pouvez les faire fonctionner sur 68k, mais ce n'est pas recommendé parce que ils prendront énormément de temp pour être afficher. Vous devez seulement utilisé les effets "!" sur des systèmes PPC, par exemple MorphOS ou WarpOS. @{b}INPUTS@{ub} id - identification de l'image de fond à afficher table - optionnel: configuration d'effet de transition @{b}EXEMPLE@{ub} DisplayTransitionFX(2, #HSTRIPES32, 10) ; ancienne syntaxe OU DisplayTransitionFX(2, {Type = #HSTRIPES32, Speed = 10}) ; nouvelle syntaxe Affiche l'image de fond 2 en utilisant l'effet #HSTRIPES32 avec une vitesse de 10. @ENDNODE @NODE LoadBGPic "Guide Hollywood" @{b}NOM@{ub} LoadBGPic -- charger une image de fond @{b}SYNOPSIS@{ub} [id] = LoadBGPic(id,filename$[,transcolor]) @{b}FONCTION@{ub} Cette commande charge l'image spécifié par filename$ dans la mémoire et lui affecte l'identification id. Si vous indiquez @{"Nil" LINK V6PrgTypeNil} comme identification, LoadBGPic() choisira automatiquement une identification vide et la renverra. Les formats d'images supportés sont png, JPEG, BMP, IFF ILBM, et bien plus selon la plate-forme avec laquelle Hollywood est utilisé. Si vous spécifiez l'argument optionel transcolor, votre image sera chargé et initialisé avec cette couleur comme masque de transparence. Cette commande est également disponible par la commande préprocesseur: @{"@BGPIC" LINK atBGPIC} pour précharger des images de fond. @{b}INPUTS@{ub} id - identificateur pour l'image de fond ou @{"Nil" LINK V6PrgTypeNil} pour la @{"sélection automatique d'id" LINK AutoIDSelect} filename$ - fichier à charger transcolor - optionnel: spécifier ici une @{"valeur RGB" LINK RGBInfo} pour avoir cette couleur affichée d'une manière transparente @{b}RESULTAT@{ub} id - optionnel: identificateur de l'image de fond; seulement retourné quand vous indiquez @{"Nil" LINK V6PrgTypeNil} comme argument 1 (voir ci-dessus) @{b}EXEMPLE@{ub} LoadBGPic(2,"dh0:MyBG.iff",$00FF00) Ceci charge "dh0:MyBG.iff" comme image de fond 2 avec la couleur verte comme masque de transparence. @ENDNODE @NODE FreeBGPic "Guide Hollywood" @{b}NOM@{ub} FreeBGPic -- libérer une image de fond @{b}SYNOPSIS@{ub} FreeBGPic(id) @{b}FONCTION@{ub} Cette commande libère la mémoire de l'image de fond spécifié par id. Pour réduire la consommation de mémoire, vous devez libérer l'image de fond quand vous n'en n'avez plus besoin. @{b}INPUTS@{ub} id - identificateur pour l'image de fond @ENDNODE @NODE LoadBrush "Guide Hollywood" @{b}NOM@{ub} LoadBrush -- charger une brosse @{b}SYNOPSIS@{ub} [id] = LoadBrush(id, filename$[, table]) @{b}FONCTION@{ub} Cette commande charge la brosse spécifié par filename$ dans la mémoire et lui affecte l'identification id. Si vous indiquez @{"Nil" LINK V6PrgTypeNil} comme id, LoadBrush () choisira automatiquement une identification vide et la renverra. Les formats supportés d'image sont png, JPEG, BMP, IFF ILBM, et bien plus selon la plate-forme sur laquelle Hollywood est utilisé. Le troisième argument est optionnel. C'est un tableau qui peut être utilisé pour régler d'autres options pour le fonctionnement de charge. Les indicateurs suivants du tableau peuvent être utilisés: Transparency : Cet indicateur peut être utilisé pour spécifier une couleur dans la @{"notation RGB" LINK RGBInfo}. Cela créera une transparence dans la brosse. LoadAlpha : Régler cet indicateur sur TRUE si le canal alpha de l'image doit également être chargé. Noter que toutes les images n'ont pas forcément un canal alpha et que tous les formats d'illustration ne sont pas forcément capables de stocker l'information de canal alpha. Il est suggéré d'utiliser le format de png si vous avez besoin des caractéristiques de canal alpha. Cet indicateur est réglé avec FALSE par défaut. X, Y, Width, Height : Ces indicateurs peuvent être utilisés pour charger une partie seulement de l'image dans la brosse. C'est utile si vous avez une grande image composé de plusieurs petites images différentes et que vous voulez charger les petites images dans des brosses. En utilisant ces indicateurs vous pouvez spécifier un rectangle à l'intérieur de l'image de lequel Hollywood copiera les données graphiques pour la brosse. Noter que les indicateurs "Transparency" et "LoadAlpha" sont mutuellement exclusif. Une brosse peut avoir seulement une option de transparence. Cette commande est également disponible par le préprocesseur: Utiliser @{"@BRUSH" LINK atBRUSH} pour précharger des brosses. @{b}INPUTS@{ub} id - identificateur pour la brosse ou @{"Nil" LINK V6PrgTypeNil} pour la @{"sélection automatique d'id" LINK AutoIDSelect} filename$ - fichier à charger table - optionnel: options de transparence et de collecte de données (voir ci-dessus) (V2.0) @{b}RESULTAT@{ub} id - optionnel: identificateur de la brosse; sera seulement retourné quand vous indiquez Nil comme argument 1 (voir ci-dessus) @{b}EXEMPLE@{ub} LoadBrush(2, "dh0:MyBrush.iff", {Transparency = #RED}) Le code charge "dh0:MyBrush.iff" en tant que brosse 2 avec la couleur rouge transparente. @ENDNODE @NODE FreeBrush "Guide Hollywood" @{b}NOM@{ub} FreeBrush -- libérer une brosse @{b}SYNOPSIS@{ub} FreeBrush(id) @{b}FONCTION@{ub} Cette commande libère la mémoire de la brosse spécifié par id. Pour limiter la consommation mémoire, vous devez libérer les brosses quand vous n'en avez plus le besoin. @{b}INPUTS@{ub} id - identificateur pour la brosse @ENDNODE @NODE DisplayBrush "Guide Hollywood" @{b}NOM@{ub} DisplayBrush -- afficher une brosse @{b}SYNOPSIS@{ub} DisplayBrush(id, x, y[, filter]) @{b}FONCTION@{ub} Cette commande affiche la brosse spécifié par id aux coordonnées spécifié par x et y. Nouveau depuis Hollywood 4.0: Vous pouvez spécifier un tableau optionnel contenant un ou plusieurs filtres à appliquer sur la brosse avant de l'afficher. Voir @{"ici" LINK FilterTable} pour plus d'information. @{b}INPUTS@{ub} id - identification de la brosse à afficher x - décalage en x à l'écran y - décalage en y à l'écran filtre - optionnel: filtre à appliquer à la brosse avant de l'afficher (V4.0) @{b}EXEMPLE@{ub} DisplayBrush(1, #CENTER, #CENTER) Affiche la brosse 1 au centre de l'écran. *** DisplayBrush(1, 0, 0, {Width = 640, Height = 480}) Affiche la brosse 1 redimensionné en 640x480. @ENDNODE @NODE DisplayBrushPart "Guide Hollywood" @{b}NOM@{ub} DisplayBrushPart -- Afficher une partie d'une brosse @{b}SYNOPSIS@{ub} DisplayBrushPart(id, srcx, srcy, destx, desty, width, height[, filter]) @{b}FONCTION@{ub} Cette commande affiche une partie de la brosse spécifié par id sur l'écran. La partie est définie par srcx, srcy, sa largeur et sa hauteur, elle est affichée sur l'écran aux positions destx et desty. Nouveau depuis Hollywood 4.0: Vous pouvez spécifier un tableau optionnel contenant un ou plus de filtres à appliquer sur la brosse avant de l'afficher. Voir @{"ici" LINK FilterTable} pour plus d'information. @{b}INPUTS@{ub} id - identification de la brosse à utiliser comme source srcx - coin gauche dans la brosse srcy - coin en haut dans la brosse destx - position désirée de x pour la brosse sur l'écran desty - position désirée de y pour la brosse sur l'écran width - largeur de la partie à afficher height - hauteur de la partie à afficher filtre - optionnel: tableau contenant des filtres à appliquer sur la brosse avant de l'afficher (V4.0) @{b}EXEMPLE@{ub} DisplayBrushPart(1,0,0,50,50,100,100) Afficher les 100 premiers pixel et colonnes de la brosse 2 sur l'écran à la position 50,50. @ENDNODE @NODE MoveBrush "Guide Hollywood" @{b}NOM@{ub} MoveBrush -- déplacer une brosse de a à b @{b}SYNOPSIS@{ub} MoveBrush(id, xa, ya, xb, yb[, table]) @{b}FONCTION@{ub} Cette commande déplace (défilement) la brosse spécifié par id doucement de la position spécifié par xa, ya à la position spécifié par xb, yb. D'autres paramètres peuvent être spécifiés dans le tableau d'argument optionnel. Les paramètres suivants sont disponibles : speed : Définit le nombre de pixel que la brosse sera déplacé par affichage. Par conséquent un numéro plus élevé signifie une vitesse plus élevée. Vous pouvez également spécifier une constante pour l'argument de vitesse (#SLOWSPEED, #NORMALSPEED ou #FASTSPEED). FX : Spécifie un effet spécial qui sera appliqué au mouvement. Les effets suivants sont actuellement disponibles : #BOUNCE : fait rebondir l'objet à la fin du déplacement #DAMPED : amortie l'objet à la fin du déplacement #SMOOTHOUT : #SINE : affiche l'objet sur une courbe sinusoïdale (*) #BIGSINE : affiche l'objet sur une grande courbe sinusoïdale (*) #LOWERCURVE : déplace l'objet sur une courbe en dessous de la ligne de déplacement (*) #UPPERCURVE : déplace l'objet sur une courbe au-dessus de la ligne de déplacement (*) Les effets identifiés par un astérisque sont seulement possibles avec un déplacement horizontale, se qui signifie que les coordonnées ya et yb doivent être égaux. Async : Vous pouvez utiliser cet indicateur pour créer un affichage d'objet asynchrone pour le déplacement. Si vous indiquez TRUE MoveBrush() sera quitté immédiatement, renvoyant la prise en charge d'objet asynchrone que vous pouvez alors afficher en utilisant AsyncDrawFrame(). Voir la documentation de @{"AsyncDrawFrame()" LINK AsyncDrawFrame} pour plus d'information sur les méthodes d'affichage d'objets asynchrones. @{b}INPUTS@{ub} id - identification de la brosse à déplacer xa - position x de la source ya - position y de la source xb - position x de la destination yb - position y de la destination table - optionnel: davantage d'option pour ce mouvement @{b}EXEMPLE@{ub} MoveBrush(1, 100, 50, 0, 50, {Speed = 5}) Déplace la brosse de 100:50 à 0:50 avec une vitesse de 5. Cette commande est très facile d'utilisation avec les constantes spéciales: MoveBrush(1, #RIGHTOUT, #BOTTOM, #LEFTOUT, #BOTTOM, {Speed = #NORMALSPEED}) Déplace la brosse de la position extérieure droite à la position extérieure gauche avec une vitesse normale. @ENDNODE @NODE ScaleBrush "Guide Hollywood" @{b}NOM@{ub} ScaleBrush -- redimensionner une brosse @{b}SYNOPSIS@{ub} ScaleBrush(id, width, height[, smooth]) @{b}FONCTION@{ub} Cette commande redimensionne la brosse spécifié par id à la largeur et à la hauteur spécifié par width et height. Eventuellement, vous pouvez choisir d'avoir des graphismes redimensionnés avec une interpolation en indiquant TRUE dans l'argument smooth. Le graphisme sera alors redimensionné en utilisant l'anti-aliasing. Note: Vous devez toujours faire des opérations de redimensionnement avec la brosse originel. Par exemple, si vous redimensionnez la brosse 1 à 12x8 et la redimensionner alors de nouveau à 640x480, vous obtiendrez une image de mauvaise qualité. Par conséquent vous devez toujours utiliser la brosse originel et seulement redimensionner des copies de cette brosse originel. Nouveau depuis V2.0: Vous pouvez indiquer #KEEPASPRAT en tant que la largeur ou hauteur. Hollywood calculerà la taille automatiquement en prenant compte du ratio hauteur/largeur de la brosse. Depuis Hollywood 2.0, la largeur et hauteur peuvent également être une chaîne contenant un des spécifications en pôurcentage, par exemple "50%". @{b}INPUTS@{ub} id - identification de la brosse à utiliser comme source width - nouvelle largeur désirée pour la brosse height - nouvelle hauteur désirée pour la brosse smooth - optionnel: si ou non le redimensionnement sera utilisé avec l'anti-aliasing (V2.5) @{b}EXEMPLE@{ub} ScaleBrush(1,640,480) Redimensionne la brosse 1 à une définition de 640x480. @ENDNODE @NODE LoadAnim "Guide Hollywood" @{b}NOM@{ub} LoadAnim -- charger une animation @{b}SYNOPSIS@{ub} [id] = LoadAnim(id, filename$[, table]) @{b}FONCTION@{ub} Cette commande charge l'animation spécifié par filename$ dans la mémoire et lui affecte l'identification id. Si vous indiquez @{"Nil" LINK V6PrgTypeNil} comme id, LoadAnim() choisir automatiquement une identification vide et la retournera. Actuellement, les animations doivent être dans le format IFF ANIM. D'autres formats seront supporté dans l'avenir. Le troisième argument est optionnel. C'est un tableau qui peut être utilisé pour régler d'autres options pour l'opération de chargement. Les indicateurs suivants du tableau peuvent être utilisé : Transparency : Cet indicateur peut être utilisé pour spécifier une couleur dans la @{"notation RGB" LINK RGBInfo} qui sera rendu transparente dans l'animation. FromDisk : Si vous réglez cet indicateur sur TRUE, Hollywood ne chargera pas l'animation entièrement dans la mémoire mais elle chargera les images directement à partir du disque quand il en aura besoin. C'est plus lent mais cela exige beaucoup moins de mémoire. Pour les fonctions de la bibliothèque d'animation, il importe peut que l'animation soit complétement charger dans la mémoire ou chargé dynamiquement à partir du disque. Vous pouvez utiliser toutes les commandes d'animations comme @{"ScaleAnim()" LINK ScaleAnim} avec les animations qui sont chargés à partir du disque. Des calques d'Animations sont également correctement traitées avec des animations sur disque. Cette commande est également disponible par le préprocesseur: Utiliser @{"@ANIM" LINK atANIM} pour précharger des animations. @{b}INPUTS@{ub} id - identificateur pour l'animation ou @{"Nil" LINK V6PrgTypeNil} pour la @{"sélection automatique d'id" LINK AutoIDSelect} filename$ - fichier à charger table - optionnel: d'autres options (voir ci-dessus) (V2.5) @{b}RESULTAT@{ub} id - optionnel: identificateur de l'animation; sera seulement retourné quand vous indiquerez @{"Nil" LINK V6PrgTypeNil} comme argument 1 (voir ci-dessus) @{b}EXEMPLE@{ub} LoadAnim(2, "dh0:MyAnim.iff", {Transparency = #RED}) Ce code charge "dh0:MyAnim.iff" comme anim 2 avec la couleur rouge transparente. @ENDNODE @NODE FreeAnim "Guide Hollywood" @{b}NOM@{ub} FreeAnim -- libérer une animation @{b}SYNOPSIS@{ub} FreeAnim (id) @{b}FONCTION@{ub} Cette commande libère la mémoire de l'animation spécifié par id. Pour réduire la consommation de mémoire, vous devrez libérer des animations quand vous n'en avez plus besoin. @{b}INPUTS@{ub} id - identificateur pour l'animation @ENDNODE @NODE MoveAnim "Guide Hollywood" @{b}NOM@{ub} MoveAnim -- déplacer une animation de a à b @{b}SYNOPSIS@{ub} MoveAnim(id, xa, ya, xb, yb[, table]) @{b}FONCTION@{ub} Cette commande déplace (défilement) l'animation spécifié par id doucement de l'emplacement spécifié par xa, ya à l'emplacement spécifié par xb, yb. D'autres options de configuration sont possibles en utilisant l'argument optionnel table. Vous pouvez spécifier la vitesse de déplacement, effets spéciaux, et si oui ou non le mouvement sera asynchrone. Veuillez voir la documentation de la commande @{"MoveBrush()" LINK MoveBrush} pour plus d'information sur le tableau d'argument optionnel. Sans compter que les éléments du tableau mentionnés dans la documentation de MoveBrush(), MoveAnim() acceptent un élément de tableau supplémentaire nommé "AnimSpeed": la valeur de la vitesse d'animation définit après combien d'image le nombre d'image devraient être augmenté; pour cette raison plus le nombre est élevé moins la vitesse de lecture d'animation sera rapide. @{b}INPUTS@{ub} id - identification de l'animation à utiliser comme source xa - position x de la source ya - position y de la source xb - position x de destination yb - position y de destination table - optionnel: davantage de configuration pour ce déplacement @{b}EXEMPLE@{ub} MoveAnim(1, 100, 50, 0, 50, {Speed = 5, AnimSpeed = 4}) Déplace l'animation 1 de 100:50 à 0:50 avec une vitesse de déplacement de 5 et l'animation sera lu à une vitesse de 4. @ENDNODE @NODE PlayAnim "Guide Hollywood" @{b}NOM@{ub} PlayAnim -- Jouer une animation @{b}SYNOPSIS@{ub} PlayAnim(id[, x, y, table]) [V4.0] PlayAnim(id[, x, y, speed, loops]) [ancienne syntaxe jusqu'à Hollywood 3.1] @{b}FONCTION@{ub} Cette commande commence à jouer une animation préchargé spécifié par id. Eventuellement vous pouvez spécifier les coordonnées x et y sur l'écran où l'animation doit être affichée. Depuis Hollywood 4.0, PlayAnim() reçoit un argument supplémentaire dans le tableau optionnel qui peut être utilisé pour configurer plusieurs type d'option de lecture : Speed : Définit la vitesse de lecture pour l'animation. Plus le nombre sera élevé plus la vitesse de lecture sera lente. Vous pouvez également spécifier une constante pour l'argument de vitesse (#SLOWSPEED #NORMALSPEED ou #FASTSPEED). Times : Spécifie combien de fois l'animation sera joué (par défauts à 1, se qui signifie que l'animation sera joué juste une fois). Si vous voulez boucler l'animation infiniment, spécifier 0. Async : Vous pouvez utiliser cet indicateur pour créer un affichage d'objet asynchrone pour cette lecture. Si vous indiquez TRUE, PlayAnim() sera quitté immédiatement, redonnant une prise en charge le traitement d'objet asynchrone ce que vous pouvez alors afficher en utilisant AsyncDrawFrame() . Voir la documentation de @{"AsyncDrawFrame()" LINK AsyncDrawFrame} pour plus d'information sur la gestion des objets asynchrones. @{b}INPUTS@{ub} id - identification de l'animation à jouer x - optionnel: position x de lecture (défauts à 0) y - optionnel: position y de lecture (défauts à 0) table - optionnel: davantage de configuration pour la lecture d'animation @{b}EXEMPLE@{ub} PlayAnim(1) Jouer l'animation 1. @ENDNODE @NODE StopAnim "Guide Hollywood" @{b}NOM@{ub} StopAnim -- arrêter une animation en cours (V1.0) @{b}SYNOPSIS@{ub} StopAnim(id) @{b}FONCTION@{ub} Cette commande a été retiré de Hollywood 1.5. Elle ne peut plus être utilisé. Cette commande arrête l'animation spécifié par id. Si l'animation spécifié par id est joué de multiple fois en arrière plan, se sera l'animation qui a été pour la dernière fois démarré qui sera arrêté par Hollywood. @{b}INPUTS@{ub} id - identification de l'animation à arrêter @ENDNODE @NODE Box "Guide Hollywood" @{b}NOM@{ub} Box -- tracer un cadre @{b}SYNOPSIS@{ub} Box(x, y, width, height[, color, round, rotate]) @{b}FONCTION@{ub} Cette commande trace un cadre de x:y avec la largeur et la hauteur spécifié et la couleur spécifié (valeur RGB). Le cadre sera dessiné sous un style de forme spécifique en utilisant @{"SetFormStyle()" LINK SetFormStyle} et sera rempli selon la configuration sélectionnée de @{"SetFillStyle()" LINK SetFillStyle}. Nouveau avec Hollywood 1.9: Vous pouvez spécifier l'argument optionnel round pour créer un rectangle avec des coins arrondis. Vous devez indiquer un niveau de round en pourcentage qui spécifie comment les coins doivent être arrondie. Nouveau avec Hollywood 2.0: La couleur peut également être en @{"valeur ARGB" LINK ARGBInfo} pour l'affichage en alpha-blended. Avec Hollywood 2.5 un argument optionnel de rotation a été ajouté. Avec cet argument vous pouvez tracer un rectangle avec une rotation. Spécifier simplement un angle entre 0 et 360 degrés et Box() tracera un rectangle avec une rotation. Cet argument est par défaut réglé à 0, se qui ne signifie aucune rotation. @{b}INPUTS@{ub} x - décalage x de la source y - décalage y de la source width - largeur désirée height - hauteur désirée color - optionnel: couleur en @{"RGB" LINK RGBInfo} ou @{"ARGB" LINK ARGBInfo} (défauts : #BLACK), la couleur est optionnelle parce qu'on ne l'exige pas quand vous générez dans un masque ou dans un canal alpha round - optionnel: arrondissement des coins en pourcentage (0-100) (défauts à 0) (V1.9) rotate - optionnel: rotation désirée pour cet objet en degrés (V2.5) @{b}EXEMPLE@{ub} Box(0, 0, 640, 480, #YELLOW) Le code ci-dessus trace un cadre jaune comme un bord d'écran 640x480. @ENDNODE @NODE Line "Guide Hollywood" @{b}NOM@{ub} Line -- tracer une ligne @{b}SYNOPSIS@{ub} Line(x1, y1, x2, y2[, color, thickness]) @{b}FONCTION@{ub} Cette commande trace une ligne de x1:y1 à x2:y2 avec la couleur spécifié (Valeur RGB). Depuis Hollywood 2.5 cette commande reçoit un nouvel argument optionnel qui peut être utilisé pour tracer des lignes épaisses. L'argument d'épaisseur est réglé par défaut à 1, se qui trace une ligne normale. Si vous voulez des lignes avec l'anti-aliasing, utiliser la commande @{"SetFormStyle()" LINK SetFormStyle} pour activé l'anti-aliasing. Nouveau avec Hollywood 2.0: La couleur peut également être une @{"valeur ARGB" LINK ARGBInfo} pour l'alpha-blended. @{b}INPUTS@{ub} x1 - décalage x de la source y1 - décalage y de la source x2 - décalage x de destination y2 - décalage y de destination color - optionnel: couleur en @{"RGB" LINK RGBInfo} ou @{"ARGB" LINK ARGBInfo} (défauts : #BLACK), la couleur est optionnelle parce qu'on ne l'exige pas quand vous générez dans un masque ou dans un canal alpha thickness - optionnel: épaisseur désirée de la ligne (défauts à 1) (V2.5) @{b}EXEMPLE@{ub} Line(0, 0, 639, 479, #WHITE) Line(639, 0, 0, 479, #WHITE) Le code ci-dessus trace une croix blanche sur l'écran. @ENDNODE @NODE Plot "Guide Hollywood" @{b}NOM@{ub} Plot -- tracer un pixel @{b}SYNOPSIS@{ub} Plot(x, y[, color]) @{b}FONCTION@{ub} Cette commande trace un pixel sur l'écran avec la couleur spécifiée. Plot() fonctionne seulement avec les calques désactivés. Si vous voulez un calque de dimension 1x1 pixel, vous pouvez utiliser @{"Box()" LINK Box} pour le réaliser. Nouveau avec Hollywood 2.0: La couleur peut également être une @{"valeur ARGB" LINK ARGBInfo} pour l'affichage alpha-blended @{b}INPUTS@{ub} x - décalage de x y - décalage de y color - optionnel: couleur en @{"RGB" LINK RGBInfo} ou @{"ARGB" LINK ARGBInfo} (défauts : #BLACK), la couleur est optionnelle parce qu'on ne l'exige pas quand vous générez dans un masque ou dans un canal alpha @{b}EXEMPLE@{ub} Plot(#CENTER, #CENTER, #RED) trace un pixel rouge au milieu de votre écran. @ENDNODE @NODE Circle "Guide Hollywood" @{b}NOM@{ub} Circle -- tracer un cercle @{b}SYNOPSIS@{ub} Circle(x, y, radius[, color]) @{b}FONCTION@{ub} Cette commande trace un cercle à la position spécifié x:y avec le radius et la couleur spécifiée (valeur RGB). Le cercle sera dessiné dans un style de forme spécifique en utilisant @{"SetFormStyle()" LINK SetFormStyle} et sera rempli selon la configuration sélectionnée avec @{"SetFillStyle()" LINK SetFillStyle}. La largeur et la hauteur du cercle sera le radius * 2 + 1 (point central). Nouveau avec Hollywood 2.0: La couleur peut également être une @{"valeur ARGB" LINK ARGBInfo} pour l'affichage de l'alpha-blended. @{b}INPUTS@{ub} x - décalage de x y - décalage de y radius - radius de votre cercle color - optionnel: couleur en @{"RGB" LINK RGBInfo} ou @{"ARGB" LINK ARGBInfo} (défauts: #BLACK), la couleur est optionnelle parce qu'on ne l'exige pas quand vous générez dans un masque ou dans un canal alpha @ENDNODE @NODE Ellipse "Guide Hollywood" @{b}NOM@{ub} Ellipse -- tracer une ellipse @{b}SYNOPSIS@{ub} Ellipse (x, y, xradius, yradius [, la couleur, tournent]) @{b}FONCTION@{ub} Cette commande trace une ellipse à la position spécifié x:y avec le radius et la couleur spécifiée (valeur de RVB). L'ellipse sera tracée dans un style de forme spécifique en utilisant @{"SetFormStyle()" LINK SetFormStyle} et sera rempli selon la configuration sélectionnée avec @{"SetFillStyle()" LINK SetFillStyle}. La largeur de l'ellipse sera le xradius * 2 + 1 (point central) et la hauteur sera le yradius * 2 + 1 (point central). Nouveau avec Hollywood 2.0: La couleur peut également être une @{"valeur ARGB" LINK ARGBInfo} pour l'affichage de l'alpha-blended. Avec Hollywood 2.5 un argument optionnel de rotation a été ajouté. Avec cet argument vous pouvez tracer une ellipse avec une rotation. Spécifier simplement un angle entre 0 et 360 degrés et ellipse() tracera une ellipse avec une rotation. Cet argument est réglé par défaut à 0, se qui ne signifie aucune rotation. @{b}INPUTS@{ub} X - décalage de x y - décalage de y xradius - xradius de votre ellipse yradius - yradius de votre ellipse color - optionnel: couleur en @{"RGB" LINK RGBInfo} ou @{"ARGB" LINK ARGBInfo} (défauts : #BLACK), la couleur est optionnelle parce qu'on ne l'exige pas quand vous générez dans un masque ou dans un canal alpha rotate - optionnel: l'angle de rotation désirée pour cette ellipse en degrés (V2.5) @ENDNODE @NODE Undo "Guide Hollywood" @{b}NOM@{ub} Undo -- défaire une opération graphique (V1.5) @{b}SYNOPSIS@{ub} Undo(type[,id,level,quiet]) @{b}FONCTION@{ub} Cette commande défait une opération graphique spécifié par le type et éventuellement l'id. Vous devez @{"activé les calques" LINK EnableLayers} afin d'utiliser cette commande. Hollywood maintient un buffer interne de toutes les opérations graphiques qu'il exécute, par exemple afficher la brosse 2. Si vous voulez retirer la brosse 2 de l'écran, indiqué juste Undo(#BRUSH,2). Les types suivants sont disponibles : #ANIM - enlever l'animation spécifié par id de l'écran #ARC - retirer l'arc dessiné avec @{"Arc()" LINK Arc} #BGPICPART - retirer les graphismes affichés avec @{"DisplayBGPicPart()" LINK DisplayBGPicPart} #BOX - retirer le rectangle dessiné avec @{"Box()" LINK Box} #BRUSH - retirer la brosse spécifié par id de l'écran #BRUSHPART - retirer les graphismes affichés avec @{"DisplayBrushPart()" LINK DisplayBrushPart} #CIRCLE - retirer le cercle tracer avec @{"Circle()" LINK Circle} #ELLIPSE - retirer l'ellipse dessinée avec @{"Ellipse()" LINK Ellipse} #LINE - retirer la ligne dessinée avec @{"Line()" LINK Line} #PLOT - retirer un pixel affiché avec @{"Plot()" LINK Plot} #POLYGON - retirer le polygone dessiné avec @{"Polygon()" LINK Polygon} #PRINT - enlever le texte affiché avec @{"Print()" LINK Print} ou @{"NPrint()" LINK NPrint} #TEXTOBJECT - enlever l'objectif textes spécifié par id de l'écran #TEXTOUT - défaire la dernière commande @{"TextOut()" LINK TextOut}; l'id n'est pas exigée L'argument optionnel id est seulement exigée pour les types qui utilisent un identificateur (#ANIM, #BGPICPART, #BRUSH, #BRUSHPART, #TEXTOBJECT). Les autres types n'exigent pas l'identification, réglée l'identification à 0 pour ces commandes. L'argument de niveau spécifie le niveau de démantèlement à utiliser. L'argument est optionnel et à défauts à 1. Le niveau de démentellement définit à quel niveau l'objet est a défaire. Par exemple, si vous affichez la brosse 3 quatre fois sur l'écran et que vous voulez retirer que le premier des 3 brosses vous devrez spécifier un niveau de 4. Pour retirer le dernier, vous devez régler le niveau à 1, qui est également celui par défaut. Par conséquent si le niveau n'est pas spécifié ou n'est pas réglé à 1, Hollywood enlévera le dernier objet affiché du type spécifié. L'argument quiet est également optionnel. Si vous le régliez avec TRUE, Hollywood enlèvera seulement l'objet spécifié depuis la liste d'objet interne mais le laissera affiché sur l'écran. Si vous indiquez FALSE, Hollywood le retirera également de l'écran. @{b}INPUTS@{ub} type - une des constantes type (voir la liste ci-dessus) id - optionnel: seulement requis pour les types qui exigent un id associé (défauts à 0) level - optionnel: niveau de démentellement (défauts à 1) quiet - optionnel: TRUE si l'objet doit seulement être enlevé en interne mais pas de l'écran (défauts à FALSE) @{b}EXEMPLE@{ub} EnableLayers() DisplayBrush(1, #CENTER, #CENTER) WaitLeftMouse Undo(#BRUSH, 1) Le code ci-dessus affiche la brosse 1 au centre de l'écran, et attend un clique de souris et le retire. EnableLayers () Print("Bonjour") Print("voici ") Print("un ") Print("test ") Print("de") Print("Undo!") WaitLeftMouse Undo(#PRINT, 0, 6) Undo(#PRINT, 0, 5) Undo(#PRINT, 0, 4) Le code ci-dessus affiche "bonjour voici un test de Undo!" sur l'écran, et attend un clique de souris et enlève alors les textes "bonjour", "voici " et "un" en utilisant l'argument optionel level de la commande undo(). @ENDNODE @NODE UndoFX "Guide Hollywood" @{b}NOM@{ub} UndoFX -- défaire une opération graphique avec la transition fx (V1.5) @{b}SYNOPSIS@{ub} UndoFX(type, id[, table]) [V4.0] UndoFX(type, id[, effect, speed, arg, level]) [ancienne syntaxe jusqu'a V3.1] @{b}FONCTION@{ub} Cette commande est comme la commande @{"Undo()" LINK Undo} mais elle utilise un effet de transition pour défaire l'opération. Voir la documentation de la commande @{"Undo()" LINK Undo} pour plus d'information. Rappelez-vous que les calques doivent être activés en utilisant cette commande. Depuis Hollywood 4.0, cette commande utilise une nouvelle syntaxe avec juste un simple tableau comme argument optionnel. L'ancienne syntaxe est encore supportée pour des raisons de compatibilité. Le tableau d'argument optionnel peut être utilisé pour configurer l'effet de transition. Les options suivantes sont disponibles : Type : Spécifie l'effet souhaité pour la transition. Pour une liste de tous les effets de transitions supporté, voir la documentation de la commande @{"DisplayTransitionFX()" LINK DisplayTransitionFX}. (défauts : #RANDOMEFFECT) Speed : Spécifie la vitesse désirée pour la transition. Plus la valeur sera élevé, plus l'effet sera rapidement affiché. (défauts : #NORMALSPEED) Parameter : Quelques effets de transition reçoivent un paramètre supplémentaire. Ils peuvent être spécifié ici. (défauts : #RANDOMPARAMETER) Async : Vous pouvez utiliser cet indicateur pour créer un objet asynchrone pour cette transition. Si vous indiquez TRUE,àUndoFX() sera quitté immédiatement, redonnant une prise en charge d'objet asynchrone que vous pouvez alors afficher en utilisant AsyncDrawFrame(). Voir la documentation de @{"AsyncDrawFrame()" LINK AsyncDrawFrame} pour plus d'information sur la prise en charge d'objet asynchrone. UndoLevel : Spécifie le niveau de démantèlement pour cette opération. Voir la documentation de @{"Undo()" LINK Undo} pour l'information sur le niveau de démantèlement. @{b}INPUTS@{ub} type - une des constantes de type (voir @{"Undo()" LINK Undo}) id - identification de l'objet table - optionnel: configuration d'effet de transition @ENDNODE @NODE IsPicture "Guide Hollywood" @{b}NOM@{ub} IsPicture -- déterminer si une image est dans un format supporté @{b}SYNOPSIS@{ub} ret=IsPicture(file$) @{b}FONCTION@{ub} Cette commande vérifiera si le fichier spécifié dans file$ est un format d'image supporté. Si il l'est, cette commande renverra TRUE, sinon FALSE. Si cette commande renvoie TRUE, vous pourrez charger l'image en utilisant @{"LoadBGPic()" LINK LoadBGPic} ou @{"LoadBrush()" LINK LoadBrush}. @{b}INPUTS@{ub} file$ - fichier à vérifier @{b}RESULTAT@{ub} ret - TRUE si l'image est dans un format supporté, sinon FALSE @ENDNODE @NODE IsAnim "Guide Hollywood" @{b}NOM@{ub} IsAnim -- déterminer si une animation est dans un format supporté @{b}SYNOPSIS@{ub} ret=IsAnim (file$) @{b}FONCTION@{ub} Cette commande vérifiera si le fichier spécifié dans file$ est un format d'animation supporté. Si il l'est, cette commande renverra TRUE, sinon FALSE. Si cette commande renvoie TRUE, vous pourrez charger l'animation en utilisant @{"LoadAnim()" LINK LoadAnim}. @{b}INPUTS@{ub} file$ - fichier à vérifier @{b}RESULTAT@{ub} ret - TRUE si l'animation est dans un format supporté, sinon FALSE @ENDNODE @NODE ScaleAnim "Guide Hollywood" @{b}NOM@{ub} ScaleAnim -- redimensionner une animation @{b}SYNOPSIS@{ub} ScaleAnim(id, width, height[, smooth]) @{b}FONCTION@{ub} Cette commande redimensionne l'animation spécifié par id à la largeur et la hauteur désiré. Noter que redimensionner une animation sur processeur 68k peut prendre un certain temps. Eventuellement, vous pouvez utiliser une interpollation sur le redimensionnement des images en indiquant TRUE dans l'argument smooth. Les images seront alors redimensionnés en utilisant l'anti-aliasing (lissage d'image = éviter la pixelisation). Nouveau depuis V2.0: Vous pouvez indiquer #KEEPASPRAT en tant que la largeur ou hauteur. Hollywood calculerà la taille automatiquement en prenant compte du ratio hauteur/largeur de l'animation en considération. Depuis Hollywood 2.0, la largeur et hauteur peuvent également être une chaîne contenant une spécifications en pourcentage, par exemple "50%". @{b}INPUTS@{ub} id - identificateur de l'animation à redimensionner width - nouvelle largeur désirée pour l'animation height - nouvelle hauteur désirée pour l'animation smooth - optionnel: si oui ou non l'anti-aliasing doit être utilisé dans le redimensionnement (V2.5) @{b}EXEMPLE@{ub} ScaleAnim(1, 320, 240) Le code ci-dessus redimensionne l'animation 1 au format 320x240. @ENDNODE @NODE GetAttribute "Guide Hollywood" @{b}NOM@{ub} GetAttribute -- obtenir des informations sur un objet @{b}SYNOPSIS@{ub} info = GetAttribute(obj, id, attr) @{b}FONCTION@{ub} Cette commande peut être utilisé pour interroger un objet Hollywood pour obtenir certaines informations. Les objets suivants peuvent être interrogés pour des informations (et ils doivent être spécifié dans le paramètre obj): #ANIM : interroger un objet d'animation #BGPIC : interroger une image de fond #BRUSH : interroger une brosse #DISPLAY : interroger l'affichage (id à zéro) #LAYER : interroger un calque #TEXTOBJECT : interroger un objet textes #SPRITE : interroger un sprite Les attributs suivants peuvent être spécifiés : #ATTRWIDTH : renvoyer la largeur de l'objet #ATTRHEIGHT : renvoyer la hauteur de l'objet #ATTRMAXWIDTH : renvoyer la largeur maximum possible (seulement #DISPLAY) #ATTRMAXHEIGHT : renvoyer la hauteur maximum possible (seulement #DISPLAY) Les attributs #ATTRMAXWIDTH, #ATTRMAXHEIGHT et #ATTRBGPIC sont seulement utilisable avec le type d'objet #DISPLAY. Ils renvoient la largeur/hauteur maximum que votre écran peut avoir ou l'id de l'image de fond actuellement affiché. Depuis Hollywood 1.5, il y a de nouveaux attributs : #ATTRTRANSPARENTCOLOR : renvoie la couleur transparente de l'objet spécifié ou #NOTRANSPARENCY #ATTRBGPIC : renvoie l'id de l'image de fond actuellement affiché (doit être utilisé avec #DISPLAY) #ATTRLAYERS : renvoie le nombre de calques dans le cache de calque de l'image de fond (doit être utilisé avec l#DISPLAY ou #BGPIC) Les nouveaux attributs suivants peuvent seulement être utilisés avec #LAYER: #ATTRTYPE : renvoie le type de calque (par exemple #PRINT) #ATTRXPOS : renvoie la position x du calque sur #ATTRYPOS : renvoie la position y du calque sur #ATTRVISIBLE : renvoie TRUE si le calque est actuelement visible, FALSE si il est cachée #ATTRLAYERID : renvoie l'id du calque spécifié; Cela a évidemment un sens si vous spécifier un nom de calque au lieu d'une id (V2.0) Nouveaux attribus dans Hollywood 2.0 ------------------------------------ Les attributs suivants peuvent être utilisés avec le #LAYER,#ANIM et #SPRITE: #ATTRNUMFRAMES : renvoie le nombre d'image que contient l'objet (V2.0) #ATTRCURFRAME : renvoie l'image qui est actuellement affiché; ne fonctionne pas avec #ANIM (V2.0) Les attributs suivants fonctionnent avec #BRUSH et #SPRITE: #ATTRHASMASK : renvoie TRUE si l'objet a un masque (V2.0) #ATTRHASALPHA : renvoie TRUE si l'objet a un canal alpha (V2.0) Depuis Hollywood 2.0, vous pouvez également interroger des partie d'objets en utilisant #SAMPLE comme type. Les attributs suivants peuvent être interrogés: #ATTRTYPE : renvoie le format des données brutes des échantillons; cet attribut renverra #MONO8, #MONO16, #STEREO8 ou #STEREO16 #ATTRDURATION : renvoie la durée de l'échantillon en millisecondes #ATTRPITCH : renvoie la fréquence de lecture de l'échantillon en hertz #ATTRPOSITION : renvoie combien de temps l'échantillon a été joué et combien de fois il a été bouclé. La position retournée sera une valeur en millisecondes (1000 millisecondes = 1 seconde). Cette valeur sera remise à l'état initial chaque fois que l'échantillon boucle afin que cette valeur retournée de position ne dépasse jamais la longueur d'échantillon. La deuxième valeur de renvoi spécifie combien de fois l'échantillon a été joué. Il sera incrémenté de 1 chaque fois que l'échantillon effectue une boucle. Si vous devez obtenir le temp total de lecture en millisecondes, multiplier juste deuxième valeurs de renvoi par la durée d'échantillon (utiliser #ATTRDURATION) et ajouter la première valeur de renvoi au résultat Les attributs suivants peuvent être utilisés avec des objets de type #MUSIC: #ATTRTYPE : renvoie le format des données brutes d'échantillon; cet attribut renverra #MONO8, #MONO16, #STEREO8 ou #STEREO16 avec des modules Protracker #ATTRDURATION : renvoie la durée de la musique en millisecondes impossible avec des modules Protracker #ATTRPITCH : renvoie la fréquence de lecture de la musique en hertz impossible avec des modules Protracker #ATTRPOSITION : renvoie la position de la musique en millisecondes impossible avec des modules Protracker #ATTRFORMAT : renvoie le format de la musique ("MPEG Audio" ou "Protracker") #ATTRBITRATE : renvoie le débit binaire de la musique; si la musique est actuellement en lecture et qu'elle utilise un débit binaire variable, vous recevrez le débit binaire de la partie actuellement joué impossible avec des modules Protracker Nouveaux attributs dans Hollywood 2.5 ------------------------------------- Ces attributs peuvent être utilisés avec le type #DISPLAY: #ATTRCURSORX : renvoie la position actuelle du curseur en x #ATTRCURSORY : renvoie la position actuelle du curseur en y Quand vous utilisez le type #DISPLAY, indiquer toujours 0 comme id. Les nouveaux attributs suivants peuvent être utilisés avec le type #SPRITE: #ATTRONSCREEN : renvoie TRUE si le sprite spécifié est actuellement affiché sur l'écran #ATTRXPOS : renvoie la position x du sprite sur l'écran #ATTRYPOS : renvoie la position y du sprite sur l'écran Nouveaux attributs dans Hollywood 3.0 ------------------------------------- Ces attributs peuvent être utilisés avec le type #DISPLAY : #ATTRXPOS : renvoie la position x de la zone d'affichage sur l'écran #ATTRYPOS : renvoie la position y de la zone d'affichage sur l'écran #ATTRBORDERLEFT : renvoie la largeur de la bordure gauche de l'affichage ou 0 si l'affichage n'a pas de bordure #ATTRBORDERRIGHT : renvoie la largeur de la bordure droite de l'affichage ou 0 si l'affichage n'a pas de bordure #ATTRBORDERTOP : renvoie la hauteur de la bordure en haut de l'affichage ou 0 si l'affichage n'a pas de bordure #ATTRBORDERBOTTOM : renvoie la hauteur de la bordure en bas de l'affichage ou 0 si l'affichage n'a pas de bordure #ATTRHOSTWIDTH : renvoie la largeur de l'écran sur lequel l'affichage est ouvert (habituellement l'écran du bureau) #ATTRHOSTHEIGHT : renvoie la hauteur de l'écran sur lequel l'affichage est ouvert (habituellement l'écran du bureau) Ces attributs peuvent être utilisés avec le type #CLIPREGION: #ATTRXPOS : renvoie la position x de la région clip #ATTRYPOS : renvoie la position y de la région clip #ATTRWIDTH : renvoie la largeur de la région clip #ATTRHEIGHT : renvoie la hauteur de la région clip Nouveaux attributs dans Hollywood 3.1 ------------------------------------- Ces attributs peuvent être utilisés avec le type #DISPLAY: #ATTRFONTASCENDER : renvoie l'ascendant de la police actuellement utilisé en pixel; l'ascendant d'une police est la taille maximale des caractères de la ligne de base jusqu'en haut de la police de caractères en majuscule;l'ascendant +la descendante est toujours égale à la hauteur (corps) de la police de caractère en pixel. #ATTRFONTDESCENDER : renvoie la descendate de la police actuellement utilisé en pixel; la descendante d'une police est la taille maximale des caractères de la ligne de base jusqu'en bas de la police de caractères en miniscule; #ATTRFONTNAME : renvoie le nom de la police actuellement sélectionnée #ATTRFONTSIZE : renvoie la taille de la police actuellement sélectionnée #ATTRFONTSCALABLE : renvoie TRUE si la police est une police vectorielle évolutive #ATTRFONTAA : renvoie TRUE si la police peut être modifié avec l'anti-aliasing (anti-crénelage) Nouveaux attributs dans Hollywood 4.0 ------------------------------------- Ces attributs peuvent être utilisés avec les types #TEXTOBJECT et #LAYER (si le calque spécifié est un calque de type #TEXTOUT, #PRINT, ou #TEXTOBJECT) #ATTRTEXT renvoie le texte de l'objet texte/calque de texte #ATTRFONTASCENDER #ATTRFONTDESCENDER #ATTRFONTNAME #ATTRFONTSIZE #ATTRFONTSCALABLE #ATTRFONTAA @{b}INPUTS@{ub} obj - type d'objet à interroger (voir la liste ci-dessus) id - l'identificateur de l'objet attr - qu'elle information à retourner @{b}RESULTAT@{ub} info - l'information que vous voulez @{b}EXEMPLE@{ub} width=GetAttribute(#DISPLAY,0,#ATTRWIDTH) Le code ci-dessus interroge l'écran pour obtenir sa largeur actuelle. Comme il y a seulement un écran, vous ne devez pas spécifier d'id @ENDNODE @NODE DisplayBrushFX "Guide Hollywood" @{b}NOM@{ub} DisplayBrushFX -- afficher une brosse avec des effets de transition @{b}SYNOPSIS@{ub} DisplayBrushFX(id, x, y[, table]) [V4.0] DisplayBrushFX(id, x, y[, type, speed, arg]) [ancienne syntaxe depuis la version 3.1] @{b}FONCTION@{ub} Cette commande est une version étendue de la commande @{"DisplayBrush()" LINK DisplayBrush}. Il affiche la brosse spécifié par id à la position indiqué par x:y et utilise un des nombreux effets de transition de Hollywood pour l'afficher. Vous devez également spécifier la vitesse pour la transition. Depuis Hollywood 4.0 cette commande utilise une nouvelle syntaxe avec juste un tableau comme argument optionnel. L'ancienne syntaxe est encore supportée pour des raisons de compatibilité. L'argument de tableau optionnel peut être utilisé pour configurer l'effet de transition. Les options suivantes sont disponibles: Type : Spécifie l'effet souhaité pour la transition. Pour une liste de toutes les transitions supporté, voir la documentation sur les effets de transition avec la commande @{"DisplayTransitionFX()" LINK DisplayTransitionFX}. (défauts : #RANDOMEFFECT) speed : Spécifie la vitesse désirée pour la transition. Plus la valeur que vous allez spécifié ici sera élevé, plus la vitesse de l'affichage de l'effet sera élevé. (défauts : #NORMALSPEED) Parameter : Quelques effets de transitions reçoivent un paramètre supplémentaire. Il peut être spécifié ici. (défauts #RANDOMPARAMETER) Async : Vous pouvez utiliser cet indicateur pour créer un objet affiché de manière asynchrone pour cette transition. Si vous indiquez True, DisplayBrushFX() sera quitté immédiatement, renvoyant une prise en charge d'objet asynchrone que vous pouvez alors afficher en utilisant AsyncDrawFrame(). Voir la documentation de @{"AsyncDrawFrame()" LINK AsyncDrawFrame} pour plus d'information. @{b}INPUTS@{ub} id - identificateur de la brosse à afficher X - position désirée de x pour la brosse y - position désirée de y pour la brosse table - optionnel: configuration pour l'effet de transition @{b}EXEMPLE@{ub} DisplayBrushFX(1, 0, 0, #VLINES, 10) ; ancienne syntaxe OU DisplayBrushFX(1, 0, 0, {Type = #VLINES, Speed = 10}); nouvelle syntaxe le code ci-dessus affiche la brosse 1 à 0:0 avec la transition #VLINES à une vitesse de 10. @ENDNODE @NODE BGPicToBrush "Guide Hollywood" @{b}NOM@{ub} BGPicToBrush -- convertir une image de fond en brosse @{b}SYNOPSIS@{ub} BGPicToBrush(bgpicid,brushid) @{b}FONCTION@{ub} Cette commande créé une copie de l'image de fond spécifié par bgpicid et la convertis en brosse qui sera disponible avec le nombre brushid. Tout sera copié ainsi la brosse sera indépendante de l'image de fond (vous pouvez la libérer après cette opération par exemple et la brosse sera toujours utilisable). @{b}INPUTS@{ub} bgpicid - image de fond à copier brushid - identification pour la nouvelle brosse @{b}EXEMPLE@{ub} BGPicToBrush(1,5) DisplayBrush(5,#CENTER,#CENTER) Le code ci-dessus copie l'image de fond 1 dans la brosse 5 et affiche cette brosse. @ENDNODE @NODE BrushToBGPic "Guide Hollywood" @{b}NOM@{ub} BrushToBGPic -- convertir une brosse en image de fond @{b}SYNOPSIS@{ub} BrushToBGPic(brushid,bgpicid) @{b}FONCTION@{ub} Cette commande créé une copie de la brosse spécifié par brushid et la converti en image de fond qui sera disponible avec le nombre bgpicid. Tout sera copié ainsi l'image de fond sera indépendante de la brosse (vous pouvez la libérer après cette opération par exemple et l'image de fond sera toujours utilisable). @{b}INPUTS@{ub} brushid - brosse à copier bgpicid - identification pour la nouvelle image de fond @{b}EXEMPLE@{ub} BrushToBGPic(1,2) DisplayBGPic(2) Le code ci-dessus copie la brosse 1 dans l'image de fond 2 et affiche cette image de fond @ENDNODE @NODE LayersIntroduction "Guide Hollywood" @{b}Introduction aux calques@{ub} Hollywood offre un système de calque puissant et facile d'utilisation qui devrez être en mesure de réaliser tout se dont vous avez besoin pour vos applications. Les calques sont les enfants d'une image de fond. Chaque image de fond a ses propres calques. Le système de calque Hollywood n'est pas activé au démarrage. Vous devez l'activé manuellement en utilisant la commande @{"EnableLayers()" LINK EnableLayers}. Une fois que les calques sont activés, chaque objet affiché à l'écran obtiendra son propre calque. Exemple: EnableLayers() DisplayBGPic(2) DisplayBrush(1, #CENTER, #CENTER) Plot(100, 100, #RED) Print("Hello World!") Box(50, 50, 100, 100, #BLUE) Le code ci-dessus affiche 4 différents types d'objets et créé en même temps 4 calques à l'image de fond numéro 2 puisque les calques ont été activés. Maintenant, chaque objet affiché obtient son propre calque, et grâce à sa, nous avons les calques suivants pour le fond image 2 : Calque 1 (id 1) : Brosse 1 aux coordonnées #CENTER : #CENTER Calque 2 (id 2) : Un Pixel rouge à 100 : 100 Calque 3 (id 3) : Le texte "Hello World!" Calque 4 (id 4) : Un cadre bleu à 50 : 50 avec les dimensions 100 : 100 Maintenant vous pouvez faire tout se que vous voulez avec ces calques, vous pouvez par exemple les cacher, déplacer, échanger leurs priorités d'affichage ou les retirer. Hollywood offre beaucoup de commande qui peuvent traiter les calques. Noter que les ids de calque sont dynamiques. Par exemple si le code au-dessus est exécuté avec la commande RemoveLayer(2) alors les ids de calque seront modifiés. Après l'exécution de cette commande, nous aurions les calques suivant pour l'image 2 de fond : Calque 1 (id 1) : Brosse 1 aux coordonnées #CENTER : #CENTER Calque 2 (id 2) : Le texte "Hello World!" Calque 3 (id 3) : Un cadre bleu à 50 : 50 avec les dimensions 100 : 100 Vous pouvez remarquer que le calque texte "Hello World!" a maintenant l'id 2 et le cadre est maintenant le calque 3. *** Depuis Hollywood 2.0, il y a une nouvelle commande disponible: @{"SetLayerName()" LINK SetLayerName}. Vous pouvez l'utiliser pour donner à vos calques un nom unique ainsi vous pouvez simplement adresser la calque par son nom au lieu du son identification. C'est très utile si vous avez beaucoup de calques et que vous ne voulez pas utiliser leurs ids. Maintenant, toutes les commandes fonctionnent avec les noms de calques sous forme de chaîne plus d'une identification numérique. Voici de nouveau notre exemple: Calque 1 (id 1) : Brosse 1 aux coordonnées #CENTER : #CENTER Calque 2 (id 2) : Un Pixel rouge à 100 : 100 Calque 3 (id 3) : Le texte "Hello World!" Calque 4 (id 4) : Un cadre bleu à 50 : 50 avec les dimensions 100 : 100 Maintenant nous faisons ce qui suit : SetLayerName(1, "brosse: 1") SetLayerName(2, "pixel rouge") SetLayerName(3, "texte: hello world") SetLayerName(4, "cadre bleu") Maintenant nous pourrions retirer la calque 2 en appelant RemoveLayer("pixel rouge") Nous n'avons plus à nous inquiéter du fait que les ids de calque ont changé puisque tous les calques ont des noms, et grâce à cette méthode, nous pouvons facilement les adresser. *** Garder à l'esprit que les calques sont toujours des image de fond privé. Par exemple si vous appelez maintenant DisplayBGPic(3) vous ne pourrez accéder à aucun calque. Si vous appelez maintenant DisplayBGPic(2) de nouveau, Hollywood affichera votre image de fond 2 avec tous les calques liés à elle. Ainsi vous pouvez en toute sécurité commuter entre vos images de fond et vous n'aurez pas à afficher toutes vos données de nouveau. Si vous avez les calques activés, Hollywood affichera tous les calques fixé à une image de fond automatiquement avec @{"DisplayBGPic()" LINK DisplayBGPic}. Pour économiser la mémoire vous devrez indiquer en utilisant @{"FreeLayers()" LINK FreeLayers} d'effacer le calque quand vous n'en avez plus besoin. Assurez-vous également que vous exécutez @{"EnableLayers()" LINK EnableLayers} avant d'afficher les objets afin de les utiliser comme calque. Par exemple, le code suivant ne fonctionnera pas: DisplayBrush(1, #CENTER, #CENTER) EnableLayers() Undo(#BRUSH, 1) Chaque commande qui affiche des graphismes vérifiera si les calques sont activés et si elles le sont, elle leurs ajoutera un calque. Par conséquent l'exemple ci-dessus ne peut pas fonctionner parce que les calques sont activés après que la commande @{"DisplayBrush()" LINK DisplayBrush} soit exécuté . Vous devez donc utiliser Le code suivant: EnableLayers() DisplayBrush(1, #CENTER, #CENTER) Undo(#BRUSH, 1) Ce code fonctionnera. Si vous voulez utiliser les calques dans votre application, il est recommandé d'exécuter @{"EnableLayers()" LINK EnableLayers} au début de votre code. Cela assure que les calques seront toujours activés. @ENDNODE @NODE EnableLayers "Guide Hollywood" @{b}NOM@{ub} EnableLayers -- activé le système de calque (V1.5) @{b}SYNOPSIS@{ub} EnableLayers() @{b}FONCTION@{ub} Cette commande permet d'acité le système incorporé de calque. utiliser toutes les commandes relative aux calques. Vous devez d'abord exécuter cette commande. Lire @{"l'introduction sur les calques" LINK LayersIntroduction} pour en savoir plus. @{b}INPUTS@{ub} aucun @ENDNODE @NODE DisableLayers "Guide Hollywood" @{b}NOM@{ub} DisableLayers -- désactiver le système de calque (V1.5) @{b}SYNOPSIS@{ub} DisableLayers() @{b}FONCTION@{ub} Cette commande désactive le système incorporé de calque. Noter que cette commande ne libère aucun des calques qui sont liés à une image de fond. Ils seront maintenus jusqu'à vous les libériez ou jusqu'à se que Hollywood soit fermé. Vous pouvez donc également désactiver les calques temporairement et les activés de nouveau plus tard dans votre code, cela ne détruira aucun calque. Lire @{"l'introduction sur les calques" LINK LayersIntroduction} pour en savoir plus. @{b}INPUTS@{ub} aucun @ENDNODE @NODE CreateBrush "Guide Hollywood" @{b}NOM@{ub} CreateBrush -- créer une brosse vide (V1.5) @{b}SYNOPSIS@{ub} CreateBrush(id, width, height[, color]) @{b}FONCTION@{ub} Cette commande créée une nouvelle brosse avec la largeur et la hauteur spécifié puis l'initialise à la couleur indiquée. Si aucune couleur n'est indiqué, la brosse sera initialisé en noir. @{b}INPUTS@{ub} id - identification pour la nouvelle brosse width - largeur de la brosse height - hauteur de la brosse color - optionnel: @{"Couleur RGB" LINK RGBInfo} pour le fond (défauts: #BLACK) @{b}EXEMPLE@{ub} CreateBrush(2, 320, 256, #BLUE) Le code ci-dessus créé une nouvelle brosse bleu avec l'identification 2 et la dimension de 320x256. @ENDNODE @NODE CreateBGPic "Guide Hollywood" @{b}NOM@{ub} CreateBGPic -- créé une image de fond vide (V1.5) @{b}SYNOPSIS@{ub} CreateBGPic(id, width, height[, color]) @{b}FONCTION@{ub} Ce commande créée une nouvelle image de fond avec la largeur et hauteur spécifié et l'initialise à la couleur indiquée. Si aucune couleur n'est indiquée, l'image de fond sera initialisée en noir. @{b}INPUTS@{ub} id - identification pour la nouvelle image de fond width - largeur de l'image de fond height - hauteur de l'image de fond color - optionnel: @{"Couleur RGB" LINK RGBInfo} pour le fond (défauts: #BLACK) @{b}EXEMPLE@{ub} CreateBGPic(2, 640, 480) Le code ci-dessus créé un nouveau BGPic noir avec l'identification 2 et la dimension de 640x480. @ENDNODE @NODE GetBrushLink "Guide Hollywood" @{b}NOM@{ub} GetBrushLink -- obtenir un lien pour une brosse (V1.5) @{b}SYNOPSIS@{ub} GetBrushLink(id, sourcetype, sourceid[, par]) @{b}FONCTION@{ub} *** NOTE POUR HOLLYWOOD 2.0 *** Les liens de brosse ne sont plus supportées. Vous pouvez encore utiliser cette commande mais il ne produira plus des tiges. Il créera simplement une copie des données de l'image; en d'autres termes: GetBrushLink() appelle juste @{"ConvertToBrush()" LINK ConvertToBrush}. *** NOTE POUR HOLLYWOOD 2.0 *** Cette commande créé une nouvelle brosse à laquelle ce joindra les données d'un autre objet. Par conséquent la nouvelle brosse sera en lecture seule. Ceci signifie, par exemple, que vous pouvez l'afficher ou le déplacer, mais vous ne pouvez pas changer ses caractéristiques (par exemple en appelant @{"ScaleBrush()" LINK ScaleBrush} ou @{"SelectBrush()" LINK SelectBrush}). Votre brosse dépend entièrement de l'objet source. Si vous libérez l'objet source, votre Brosse sera également libéré et ne sera plus disponible. Les liens de brosse requiert que peu d'octets de mémoire puisque les caractéristiques graphiques seront jointes depuis l'objet source. Il est utile d'utiliser les liens de brosse quand vous avez beaucoup d'objets avec les mêmes caractéristiques graphiques et que vous voulez y accéder comme avec des brosses séparés (par exemple pour des raisons de commodité). Une autre bonne raison pour les liens de brosse est que vous pouvez faire bien plus de choses avec des brosses qu'avec d'autres objets. Par exemple vous pourriez retrouver un lien de la première image d'une animation, et l'afficher avec @{"DisplayBrushFX()" LINK DisplayBrushFX} et commencer alors l'animation avec @{"PlayAnim()" LINK PlayAnim}. Vous pourriez ainsi afficher l'animation avec un effet de transition. Sourcetype peut être l'un des types suivants : #ANIM - obtenir des liens de brosse d'une image de l'animation; ce type exige l'argument optionnel par qui spécifie l'image que vous voulez joindre #BGPIC - obtenir un lien de brosse d'une image de fond #BRUSH - obtenir un lien de brosse d'une autre Brosse #LAYER - obtenir un lien de brosse d'un calque (exige que les calques soient activés) #TEXTOBJECT - obtenir un lien de brosse d'un objet textes @{b}INPUTS@{ub} id - identification de la brosse qui sera créé sourcetype - type de l'objet source (voir la liste ci-dessus) sourceid - identification de l'objet source par - optionnel: actuellement requis pour le type #ANIM seulement @{b}EXEMPLE@{ub} LoadAnim(1, "dh0:Animations/MyAnim.anm") GetBrushLink(1, #ANIM, 1, 1) DisplayBrushFX(1, #CENTER, #CENTER, #CROSSFADE) PlayAnim(1, #CENTER, #CENTER) Le code ci-dessus charge l'animation "MyAnim.anim" depuis "dh0 :Animations" obtient un lien de brosse de la première image, applique sur cette image l'effet de transition crossfade à l'écran et commence alors à lire l'animation. vous pouvez afficher une animation avec un effet de transition. @ENDNODE @NODE SelectBrush "Guide Hollywood" @{b}NOM@{ub} SelectBrush -- sélectionner une brosse comme périphérique de sortie (V1.5) @{b}SYNOPSIS@{ub} SelectBrush(id) @{b}FONCTION@{ub} Cette commande sélectionne la brosse spécifié par id comme périphérique de sortie. Ceci signifie que toutes les données graphiques qui seront affiché par Hollywood seront sauvegardés dans votre brosse. Contrairement à @{"SelectBGPic()" LINK SelectBGPic}, les données graphiques seront sauvegardés immédiatement dans votre brosse se qui signifie que les données graphiques de votre brosse seront modifiées. Cette commande fonctionne également avec les calques désactivées. Si vous avez terminé avec le rendu de votre Brosse et que vous voulez que les éléments afficher à l'écran soient sauvegarder dans la brosse, exécuter juste @{"EndSelect()" LINK EndSelect}. Vous ne pouvez pas utiliser les liens de brosse avec cette commande parce que les données graphiques de la brosse spécifié par id seront changées. Il est également interdit d'appeler les commandes qui changent les dimensions de la brosse qui est actuellement utilisé comme périphérique de sortie, par exemple vous ne pouvez pas appeler @{"ScaleBrush()" LINK ScaleBrush} pour redimensionner la brosse qui est le périphérique de sortie actuel. Seule les commandes qui affiche directement des images peuvent être utilisées après SelectBrush(). Vous ne pouvez pas appeler les commandes d'animations comme @{"MoveBrush()" LINK MoveBrush} ou @{"DisplayBrushFX()" LINK DisplayBrushFX} alors que SelectBrush() est activé. @{b}INPUTS@{ub} id - brosse qui sera utilisé comme périphérique de sortie @{b}EXEMPLE@{ub} CreateBrush(1, 320, 256) SelectBrush(1) SetFillStyle(#FILLCOLOR) Box(0, 0, 320, 256, #RED) EndSelect() MoveBrush(1, #CENTER, #BOTTOMOUT, #CENTER, #TOPOUT, 10) Le code ci-dessus créé une brosse de 320x256, trace un rectangle rouge à l'intérieur et déplace alors le rectangle sur l'écran. Ceci est un exemple très abstrait. Vous pouvez naturellement faire bien plus avec cette commande aller voir juste les exemples fournis avec la distribution d'Hollywood. Ils utilisent SelectBrush() dans des fonctions plus avancés. @ENDNODE @NODE SelectBGPic "Guide Hollywood" @{b}NOM@{ub} SelectBGPic -- sélectionner une image de fond comme périphérique de sortie (V1.5) @{b}SYNOPSIS@{ub} SelectBGPic(id) @{b}FONCTION@{ub} Cette commande sélectionne le BGPic spécifié par id comme périphérique de sortie. Ceci signifie que toutes les données graphiques qui seront affichées par Hollywood sera ajoutée comme calques à ce fond d'écran. Par conséquent vous devez activer les calques avant d'utiliser cette commande. Votre image de fond ne sera pas modifiée (contrairement à @{"SelectBrush()" LINK SelectBrush}), elle obtiendra juste de plus en plus de calques. Si vous avez terminé le rendu de votre BGPic et que vous voulez maintenant sauvegarder le nouveau périphérique de sortie, exécuté juste @{"EndSelect()" LINK EndSelect}. Seule les commandes qui affichent directement des images pourront être utilisées après SelectBGPic(). Vous ne pouvez pas exéuter les commandes d'animations comme @{"MoveBrush()" LINK MoveBrush} ou @{"DisplayBrushFX()" LINK DisplayBrushFX} alors que SelectBGPic() est activé. @{b}INPUTS@{ub} id - image de fond qui sera utilisée comme périphérique de sortie @{b}EXEMPLE@{ub} EnableLayers() SelectBGPic(2) TextOut(#CENTER, #CENTER, "Hello World") Box(0, 0, 100, 100, #RED) Box(#RIGHT, #BOTTOM, 100, 100, #BLUE) EndSelect() DisplayBGPic(2) Le code ci-dessus sélectionne l'image de fond 2 comme périphérique de sortie et lui ajoute trois calques (un texte et deux rectangles). Ensuite, l'écran est sélectionné comme périphérique de sortie et alors l'image de fond 2 est affichée avec ses trois calques. @ENDNODE @NODE EndSelect "Guide Hollywood" @{b}NOM@{ub} EndSelect -- sélectionner l'écran comme périphérique de sortie (V1.5) @{b}SYNOPSIS@{ub} EndSelect() @{b}FONCTION@{ub} Cette commande annule le mode de rendu en écran en sélectionnant l'affichage comme nouveau périphérique de sortie. Toutes les commandes qui affichent des images généront de nouveau sur l'écran. Noter que les commandes SelectXXX()/EndSelect() ne s'emboîtent pas, c.-à-d. EndSelect() sélectionnera toujours l'écran comme périphérique de sortie, même si ce n'était pas le périphérique de sortie quand SelectXXX() a été exécuté. SelectBrush(1) Box(0, 0, 100, 100, #RED) ; trace un rectangle dans la brosse #1 SelectBrush(2) Box(0, 0, 100, 100, #GREEN) ; trace un rectangle dans la brosse #2 EndSelect ; choisi l'écran comme périphérique de sortie (pas la brosse #1 ! ! !) EndSelect ; Erreur ! L'écran est déjà le périphérique de sortie ! @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} voir @{"SelectBGPic()" LINK SelectBGPic} voir @{"SelectBrush()" LINK SelectBrush} @ENDNODE @NODE SetFillStyle "Guide Hollywood" @{b}NOM@{ub} SetFillStyle -- Définir le style de remplissage pour les commandes graphiques (V1.5) @{b}SYNOPSIS@{ub} SetFillStyle(style) SetFillStyle(#FILLGRADIENT, type, startcolor, endcolor[, angle]) (V2.0) SetFillStyle(#FILLTEXTURE, brush_id) (V2.0) @{b}FONCTION@{ub} Cette commande vous permet de définir le style de remplissage pour les commandes @{"Box()" LINK Box}, @{"Circle()" LINK Circle}, @{"Ellipse()" LINK Ellipse} and @{"Polygon()" LINK Polygon}. Par défaut, le style de remplissage est réglé avec #FILLNONE, cela signifie que seul le contour des formes seront affiché. Seule les styles de remplissage suivants sont actuellement supportés: #FILLCOLOR - remplir l'objet avec une couleur #FILLNONE - afficher juste les contours Depuis Hollywood 2.0, d'autres styles de remplissage ont été ajouté: #FILLGRADIENT : Remplir un objet avec un dégradé de couleur. Vous devez spécifier trois arguments qui définissent le type de dégradé ainsi que ses couleurs; vous pouvez spécifier l'argument optionnel angle qui qui fera pivoter le dégradé; voir @{"CreateGradientBGPic()" LINK CreateGradientBGPic} pour plus d'information #FILLTEXTURE : Remplir un objet avec une texture. Vous devez spécifier un argument supplémentaire qui spécifie l'id de la brosse et elle sera utilisée comme texture @{b}INPUTS@{ub} style - l'id du style comme indiquée ci-dessus ... - les arguments supplémentaires dépendant du style choisi @{b}EXEMPLE@{ub} SetFillStyle(#FILLCOLOR) Box(0, 0, 320, 256, #RED) Affiche un rectangle rempli avec la couleur rouge à 0:0 avec une dimension de 320x256. @ENDNODE @NODE CopyBrush "Guide Hollywood" @{b}NOM@{ub} CopyBrush -- copier une brosse (V1.5) @{b}SYNOPSIS@{ub} CopyBrush(source, dest) @{b}FONCTION@{ub} Cette commande copie la brosse spécifié par source et créé une copie dans la brosse dest. La nouvelle brosse est indépendante de l'ancienne ainsi vous pourrez libérer la brosse source une fois qu'elle a été copié. @{b}INPUTS@{ub} source - identification de la brosse source dest - identification de la brosse à créé @{b}EXEMPLE@{ub} CopyBrush(1, 10) FreeBrush(1) Le code ci-dessus créé une nouvelle brosse 10 qui contient les mêmes données graphiques que la brosse 1. Alors il libère la brosse 1 parce qu'elle n'a plus d'utilité. @ENDNODE @NODE SetBrushTransparency "Guide Hollywood" @{b}NOM@{ub} SetBrushTransparency -- définir la couleur transparente d'une brosse (V1.5) @{b}SYNOPSIS@{ub} SetBrushTransparency(id, col) @{b}FONCTION@{ub} Cette commande transforme la couleur spécifié par col en une couleur transparente dans la brosse avec l'identification id. Ceci est réalisé en créant un masque pour la brosse. SetBrushTransparency() scannera toutes les pixel de la brosse et masquera toutes les pixel qui ont la couleur spécifiée. Le masque qui est créé par cette commande n'est pas automatiquement mis à jour quand vous appelez @{"SelectBrush()" LINK SelectBrush} pour modifier les pixels de votre brosse. Par conséquent, il est nécessaire pour appeler SetBrushTransparency() de nouveau après un appel @{"SelectBrush()" LINK SelectBrush}, ainsi le masque sera mis à jour également. Vous pouvez également utiliser cette commande pour retirer un masque d'une brosse. Indiquer juste #NOTRANSPARENCY comme couleur. @{b}INPUTS@{ub} id - identification de la brosse source col - couleur à afficher d'une manière transparente ou #NOTRANSPARENCY pour retirer le masque de la brosse @{b}EXEMPLE@{ub} CreateBrush(1, 320, 256) SelectBrush(1) SetFillStyle(#FILLCOLOR) Circle(0, 0, 100, #RED) EndSelect() SetBrushTransparency(1, #BLACK) MoveBrush(1, #CENTER, #BOTTOMOUT, #CENTER, #TOPOUT, 10) Le code ci-dessus créé une brosse, trace un cercle plein dessus et défini la couleur noir d'arrière plan comme couleur transparente. Ensuite il déplace le cercle sur l'écran. Il est important que vous exécutiez SetBrushTransparency() une fois que vous avez terminer avec le périphérique de sorti, c.-à-d. après avoir appelé @{"EndSelect()" LINK EndSelect}. @ENDNODE @NODE LoadAnimFrame "Guide Hollywood" @{b}NOM@{ub} LoadAnimFrame -- charger une image d'une animation (V1.5) @{b}SYNOPSIS@{ub} LoadAnimFrame(id, frame, anim$[, transcolor]) @{b}FONCTION@{ub} Cette commande charge une seule image d'une animation dans la brosse spécifié par id. Le fichier d'animation est spécifié par la chaîne anim$. L'argument frame spécifie quel image doit être chargé. Si vous voulez charger la dernière image, régler frame à -1. L'argument optionnel transcolor vous permer de spécifier une couleur transparente si votre l'animation le nécessite. @{b}INPUTS@{ub} id - brosse qui contiendra l'image d'une animation frame - image a charger (s'échelonne de 1 au nombre d'image dans l'animation); spécifier -1 si vous voulez charger la dernière image anim$ - fichier d'animation transcolor - optionnel: couleur transparente à utiliser (#NOTRANSPARENCY par défaut) @{b}EXEMPLE@{ub} LoadAnimFrame(1, 5, "dh0:Animations/HugeAnim.anm") DisplayBrushFX(1, #CENTER, #CENTER, #CROSSFADE) Le code ci-dessus charge l'image 5 de l'animation "dh0:Animations/HugeAnim.anm" dans la brosse 1 et affiche cette brosse avec l'effet crossfade @ENDNODE @NODE PlayAnimDisk "Guide Hollywood" @{b}NOM@{ub} PlayAnimDisk -- jouer une animation directement à partir du disque (V1.5) @{b}SYNOPSIS@{ub} PlayAnimDisk(anim$[, x, y, frameskip, speed, transcolor, times]) @{b}FONCTION@{ub} Cette commande joue l'animation spécifié par anim$ directement à partir du disque. C'est utile si vous voulez afficher de grandes animations qui ne peut être charger entièrement dans votre mémoire. Naturellement, cette commande est beaucoup de plus lente que @{"PlayAnim()" LINK PlayAnim} qui joue une animation stocké en mémoire. La nouveauté dans Hollywood 1.9 est l'argument optionnel times qui vous permet de spécifier combien de fois l'animation sera joué. se qui signifie que l'animation est seulement jouée une fois. Si vous voulez boucler l'animation indéfiniment, spécifier 0. Note importante: Depuis Hollywood 2.5 il est préférable d'utiliser @{"LoadAnim()" LINK LoadAnim} avec " FromDisk " régler sur TRUE pour les animations sur disque. Ceci vous donne d'avantage de souplesse puisque vous pouvez également utiliser les autres commandes de la bibliothèque d'animation (comme @{"ScaleAnim()" LINK ScaleAnim} etc.) et accéder aux animations comme des calques en utilisant @{"NextFrame()" LINK NextFrame} - se qui est impossible avec PlayAnimDisk(). @{b}INPUTS@{ub} anim$ - fichier d'animation à jouer x - optionnel: position x sur l'écran pour l'animation (défauts à 0) y - optionnel: position y sur l'écran pour l'animation (défauts à 0) frameskip - optionnel: saut d'image (défauts à 0) speed - optionnel: délai après chaque images en ticks (défauts à 0) transcolor - optionnel: couleur transparente pour l'animation (défauts à #NOTRANSPARENCY) times - optionnel: spécifie combien de fois l'animation devra être joué (défauts à 1) (V1.9) @{b}EXEMPLE@{ub} PlayAnimDisk("dh0:Animations/LargeAnim.anm", 0, 0, 3) Le code ci-dessus joue l'animation "dh0:Animations/LargeAnim.anm" et sautes 3 images par démarrage. @ENDNODE @NODE EnablePrecalculation "Guide Hollywood" @{b}NOM@{ub} EnablePrecalculation -- activer la pré-calculation (V1.5 seulement) @{b}SYNOPSIS@{ub} EnablePrecalculation() @{b}FONCTION@{ub} Attention: Cette commande a été retirée depuis Hollywood 1.9. Cette commande permet la pré-calculation pour certains effets qui demande d'intense ressources CPU depuis @{"DisplayTransitionFX()" LINK DisplayTransitionFX}. Les effets qui supportent la pré-calculation, seront alors pré-calculé. C'est seulement utile sur les systèmes 68k. Les systèmes PPC doivent être en mesure d'afficher ces effets en temps réel. @{b}INPUTS@{ub} aucun @ENDNODE @NODE DisablePrecalculation "Guide Hollywood" @{b}NOM@{ub} DisablePrecalculation -- désactiver la pré-calculation (V1.5 seulement) @{b}SYNOPSIS@{ub} DisablePrecalculation() @{b}FONCTION@{ub} Attention : Cette commande a été retirée depuis Hollywood 1.9. Cette commande désactive la pré-calculation de certains effets. @{b}INPUTS@{ub} aucun @ENDNODE @NODE ReadPixel "Guide Hollywood" @{b}NOM@{ub} ReadPixel -- lire un pixel sur le périphérique de sortie (V1.5) @{b}SYNOPSIS@{ub} col = ReadPixel(x, y) @{b}FONCTION@{ub} Cette commande li un pixel spécifié par les coordonnées x;y du périphérique de sortie et renvois sa couleur actuelle. Note: La couleur retournée par cette commande peut légèrement varier de la couleur originelle à cette position. Par exemple, si vous avez une brosse qui est complètemen blanc (c.-à-d. tous les Pixel ont la couleur $FFFFFF). Si vous utilisez ReadPixel() à cet instant pour afficher la couleur d'un pixel arbitrairement de cette brosse, vous recevrez la couleur $FFFFFF seulement si Hollywood fonctionne sur des écrans 24 bits ou 32 bits. Si Hollywood fonctionne sur un écran en 16 bits, vous obtiendrà la couleur $FCF8FC, sur un écran en 15 bits vous recevriez $F8F8F8. C'est parce que ces écrans n'ont pas 16.7 millions de couleurs mais seulement 65536 (les écrans de 16 bits) ou 32768 (écrans de 15-bit). Vous pouvez utiliser la commande @{"GetRealColor()" LINK GetRealColor} pour obtenir la couleur qui représente la couleur spécifié sur l'écran. Si le périphérique de sortie actuel est le masque d'une brosse, alors ReadPixel() renverra 0 si le pixel est invisible ou 1 si le pixel est visible. Si le périphérique de sortie actuel est le canal alpha d'une brosse, alors ReadPixel() renverra le niveau de transparence du pixel demandé qui s'échelonne de 0 (pleine transparence) à 255 (aucune transparence). @{b}INPUTS@{ub} x - coordonnées x du pixel y - coordonnées y du pixel @{b}RESULTAT@{ub} col - couleur ou réglage de transparence du pixel à la position spécifié @{b}EXEMPLE@{ub} CreateBrush(1, 320, 256) SelectBrush(1) SetFillStyle(#FILLCOLOR) Box(0, 0, 320, 256, #GREEN) a = ReadPixel(100, 100) EndSelect() Le code ci-dessus affiche un rectangle vert dans la brosse 1 et li le pixel à 100:100. La variable a reçoit la valeur #GREEN puisque la brosse est rempli en totalité de vert. @ENDNODE @NODE AddMove "Guide Hollywood" @{b}NOM@{ub} AddMove -- ajouter un objet dans la liste de mouvement (V1.5) @{b}SYNOPSIS@{ub} [id] = AddMove(id, type, sourceid[, par1, par2, par3]) @{b}FONCTION@{ub} Cette commande ajoute un objet dans la liste de mouvement spécifié par id. Si la liste de mouvement n'existe pas encore, elle est créée par cette commande. Vous pouvez également indiquer @{"Nil" LINK V6PrgTypeNil} comme id se qui entraînerà la création d'une nouvelle liste de mouvement par AddMove() dans tous les cas et retournera son id. Les listes de mouvement sont utilisées pour optimisé les déplacements en utilisant DoMove(). Les paramètres optionnels par1, par2 et par3 spécifient différents éléments selon le type d'objet utilisé. Les types d'objets suivants sont actuellement supportés par AddMove(): #BRUSH - ajoute une brosse avec l'identification sourceid dans la liste de mouvement par1 spécifie la position x et le par2 la position y de la brosse ; par 3 n'est pas utilisée #HIDEBRUSH - cache la brosse avec l'identification spécifié par sourceid les paramètres optionnels ne sont pas utilisés #HIDELAYER - cache le calque spécifié par sourceid ; les paramètres optionnels ne sont pas utilisés #INSERTBRUSH - Insert la brosse spécifié par sourceid à la position du calque spécifié par par3; par1 spécifie la position x de la brosse et par2 la position y; voir la documentation de @{"InsertLayer()" LINK InsertLayer} #LAYER - ajoute le calque spécifié par sourceid dans la liste de mouvement; par1 spécifie la position x du calque, par2 la position y. Nouveau depuis Hollywood 4.0: par3 peut être utilisé pour spécifier un mode de visibilité: 0 "voir le calque", 1 "cache le calque", et 2 " maintenir le réglage de visibilité utilisé" (c.-à-d. le calque restera cachés s'il est actuellement caché) défauts par3 à 0 se qui signifie de toujours afficher le calque même si elle est actuellement cachée #NEXTFRAME - afficher une nouvelle image d'un calque d'animation; par1 spécifie la nouvelle position x du calque, par2 la position y; par3 spécifie l'image à afficher ; indiquer 0 pour afficher la prochaine image, -1 pour afficher la dernière image de l'animation (V2.0) #NEXTFRAME2 - idem que #NEXTFRAME mais prend une identification de calque comme sourceid;ceci permet d'addresser des calques d'animation directement;par1 spécifie la nouvelle position en x du calque par2 la position en y; par3 spécifie l'image à afficher indiquer 0 pour afficher la prochaine image, -1 pour afficher la dernière image de l'animation (V2.5) #REMOVELAYER - retirer le calque spécifié par sourceid du cache de calque de de l'image de fond ; optionnel les paramètres optionnels ne sont pas utilisés #TEXTOBJECT - ajoute un objet des textes spécifique par le sourceid à la liste de mouvement ; par1 spécifie la position x et par2 la position y ; par3 n'est pas utilisé #UNDO - ajoute une opération @{"Undo()" LINK Undo} à la liste de mouvement; sourceid spécifie le type de l'objet à défaire, par1 spécifie l'identification de l'objet à défaire, par2 spécifie le niveau de démantèlement ; veuillez voir la documentation de @{"Undo()" LINK Undo} pour plus d'information sur ces opérations. Après avoir rempli liste de mouvement d'objets, vous pouvez appeler @{"DoMove()" LINK DoMove} pour afficher le nouvel écran. Note: Il est impossible d'avoir de multiples objets du même type et d'id dans votre liste de mouvement. Par exemple, vous ne pouvez pas faire ce qui suit: DisplayBrush(1, #LEFT, #TOP) ; affiche la brosse 1 en haut à gauche DisplayBrush(1, #RIGHT, #BOTTOM) ; affiche la brosse 1 en bas à droite /* ceci ne fonctionnera pas * AddMove(1, #BRUSH, 1, #CENTER, #CENTER) AddMove(1, #BRUSH, 1, #LEFTOUT, #TOPOUT) /* ceci ne fonctionnera pas * DoMove(1) Le code ci-dessus ne fonctionnera pas parce que vous utilisez la brosse 1 deux fois dans la liste de déplacement. Hollywood ne sait pas quel brosse est a utiliser ce qui entraînera des résultats imprévisibles. Lire la documentation de @{"DoMove()" LINK DoMove}. @{b}INPUTS@{ub} id - identification de la liste de mouvement ou @{"Nil" LINK V6PrgTypeNil} pour créer une nouvelle liste de mouvement type - type de l'objet à ajouter (voir la liste ci-dessus) sourceid - dépend du type spécifié (voir la liste ci-dessus) par1 - dépend du type spécifié (voir la liste ci-dessus) par2 - dépend du type spécifié (voir la liste ci-dessus) par3 - dépend du type spécifié (voir la liste ci-dessus) @{b}RESULTAT@{ub} id - optionnel: identificateur de la liste de mouvement ; sera seulement retourné quand vous indiquez @{"Nil" LINK V6PrgTypeNil} comme argument 1 (voir ci-dessus) @{b}EXEMPLE@{ub} Voir @{"DoMove()" LINK DoMove} @ENDNODE @NODE DoMove "Guide Hollywood" @{b}NOM@{ub} DoMove -- afficher une liste de mouvement (V1.5) @{b}SYNOPSIS@{ub} DoMove(id) @{b}FONCTION@{ub} cette commande affiche tous les objets qui ont été ajoutés dans la liste de déplacement spécifié par id (en utilisant @{"AddMove()" LINK AddMove}). Ceci est très utile si vous voulez afficher des images animées avec différents objets. Si vous afficher chaque objet avec @{"DisplayBrush()" LINK DisplayBrush}. Votre écran clignotera selon le nombre de brosse affiché. Ceci peut être évité en mettant à jour l'affichage avec une seule opération de rafraichissement. DoMove() vous permet de réaliser ceci: Vous ajoutez tous les objets qui doivent être affiché dans une liste de mouvement (en utilisant @{"AddMove()" LINK AddMove}) et ensuite vous appelez DoMove() qui affichera cette liste de mouvement en utilisant juste une seul opération de rafraîchissement. Le plus de la commande DoMove() est qu'elle analyse la liste de mouvement que vous spécifiez et examine quels objets seront a afficher. Pour chaque objet qui est dans la liste, Hollywood vérifiera si l'objet est déjà sur l'écran. Si il l'est, Hollywood déplacera l'objet à sa nouvelle position. Si elle n'est pas sur l'écran, il sera affiché. Par conséquent si tous les objets qui doivent être affichés sont déjà sur l'écran alors ils seront juste déplacés avec DoMove(), toutes les positions de calques seront maintenues. Si il y a des objets dans la liste de mouvement qui ne sont pas actuellement affiché sur l'écran, ils seront affichés et obtiendront la meilleur position de calque affecté . Après que DoMove() est terminé, vous devrez appeler @{"ClearMove()" LINK ClearMove}. Ceci libérerà la liste de mouvement que vous avez spécifié et vous pourrez de nouveau l'utilisé avec les nouvelles positions de l'objet. cette commande exige @{"l'activation des calques" LINK EnableLayers}. @{b}INPUTS@{ub} id - identification de la liste de mouvement à afficher @{b}EXEMPLE@{ub} EnableLayers() For x = 0 To 400 AddMove(1, #BRUSH, 1, x, 0) AddMove(1, #BRUSH, 2, x, 100) AddMove(1, #BRUSH, 3, x, 200) AddMove(1, #BRUSH, 4, x, 300) DoMove(1) ClearMove(1) Next Le code ci-dessus déplace les brosses 1 à 4 de 0 à 400. Vous ne verrez aucun clignotement parce que nous utilisons la technique de liste de mouvement. @ENDNODE @NODE ClearMove "Guide Hollywood" @{b}NOM@{ub} ClearMove -- efface la liste de mouvement (V1.5) @{b}SYNOPSIS@{ub} ClearMove(id) @{b}FONCTION@{ub} Cette commande libère tous les objets qui sont dans la liste de mouvement spécifié par id. Après que vous ayez appelé cette commande, votre liste de mouvement sera de nouveau vide et pourra contenir de nouveaux objets. Voir la documentation de @{"DoMove()" LINK DoMove} et @{"AddMove()" LINK AddMove} pour plus d'information. @{b}INPUTS@{ub} id - identification de la liste de mouvement à effacer @{b}EXEMPLE@{ub} voir @{"DoMove()" LINK DoMove} @ENDNODE @NODE HideLayer "Guide Hollywood" @{b}NOM@{ub} HideLayer -- cacher un calque (V1.5) @{b}SYNOPSIS@{ub} HideLayer(id) @{b}FONCTION@{ub} cette commande cache le calque spécifié par id qui est affiché. Le calque ne sera pas effacé. Il sera juste cachée. Vous pouvez de nouveau l'afficher, en utilisant @{"ShowLayer()" LINK ShowLayer}. Si vous voulez le retirer complétement, utiliser @{"RemoveLayer()" LINK RemoveLayer} ou @{"Undo()" LINK Undo}. Vous avez besoin @{"d'activer les calques" LINK EnableLayers} avant d'utiliser cette commande. Pour comprendre le fonctionnement des calques, lire @{"l'introduction aux calques" LINK LayersIntroduction}. @{b}INPUTS@{ub} id - identificateur ou nom du calque à cacher @{b}EXEMPLE@{ub} EnableLayers() NPrint("Hello World!") WaitLeftMouse HideLayer(1) WaitLeftMouse ShowLayer(1) Le code ci-dessus affiche "Hello World!", puis cache ce texte et l'affiche de nouveau. @ENDNODE @NODE ShowLayer "Guide Hollywood" @{b}NOM@{ub} ShowLayer -- afficher ou déplacer un calque (V1.5) @{b}SYNOPSIS@{ub} ShowLayer(id[, x, y]) @{b}FONCTION@{ub} cette commande affiche le calque cachée spécifé par id que vous pouvez cacher en utilisant @{"HideLayer()" LINK HideLayer}. Vous avez besoin @{"d'activer les calques" LINK EnableLayers} avant d'utiliser cette commande. Pour comprendre le fonctionnement des calques, lire @{"l'introduction aux calques" LINK LayersIntroduction}. Depuis Hollywood 2.0 deux arguments optionnels X et Y ont été ajouté. Vous pouvez utiliser ces deux arguments pour repositionner le calque spécifié. Ainsi vous pouvez déplacer un calque à une nouvelle position en utilisant cette commande. Les deux les arguments par défaut sont réglés avec #USELAYERPOSITION, se qui signifie que le calque ne peut pas être déplacé si vous ne spécifiez pas ces arguments. @{b}INPUTS@{ub} id - identificateur ou nom du calque à afficher x - optionnel: nouvelle position en x du calque (défauts : #USELAYERPOSITION) y - optionnel: nouvelle position en y du calque (défauts : #USELAYERPOSITION) @{b}EXEMPLE@{ub} voir @{"HideLayer()" LINK HideLayer} @ENDNODE @NODE RemoveLayer "Guide Hollywood" @{b}NOM@{ub} RemoveLayer -- effacer un calque (V1.5) @{b}SYNOPSIS@{ub} RemoveLayer(id) @{b}FONCTION@{ub} cette commande efface le calque spécifié par id. C'est le même fonctionnement que la commande @{"Undo()" LINK Undo} excepté que cette commande reçoit l'id du calque directement. Avec @{"Undo()" LINK Undo} vous devez spécifier un type, un id et peut-être également un niveau pour undo, maintenant vous n'avez juste qu'a spécifier l'id du calque. Vous avez besoin @{"d'activer les calques" LINK EnableLayers} avant d'utiliser cette commande. Pour comprendre le fonctionnement des calques, lire @{"l'introduction aux calques" LINK LayersIntroduction}. @{b}INPUTS@{ub} id - identificateur ou nom du calque à effacer @ENDNODE @NODE SwapLayers "Guide Hollywood" @{b}NOM@{ub} SwapLayers -- échanger les positions de deux calques (V1.5) @{b}SYNOPSIS@{ub} SwapLayers(a, b) @{b}FONCTION@{ub} Cette commande échange les positions des calques a et b (a et b étant des id). Ceci peut être très utile si vous devez repositionner vos calques. Vous avez besoin @{"d'activer les calques" LINK EnableLayers} avant d'utiliser cette commande. Pour comprendre le fonctionnement des calques, lire @{"l'introduction aux calques" LINK LayersIntroduction}. @{b}INPUTS@{ub} a - id ou nom du calque 1 b - id ou nom du calque 2 @{b}EXEMPLE@{ub} EnableLayers() SetFillStyle(#FILLCOLOR) Box(0, 0, 150, 150, #RED) Box(0, 0, 100, 100, #GREEN) WaitLeftMouse SwapLayers(1, 2) Le code ci-dessus trace un rectangle plein en rouge et un en vert et échange la position de ces calque, se qui signifie que le rectangle vert plus petit est soudainement invisible. Avant d'échanger, le rectangle rouge était le calque 1 et le vert le calque 2. Après échange, le rectangle vert est devenu le calque 1 et le rectangle rouge est devenu le calque 2. @ENDNODE @NODE FreeLayers "Guide Hollywood" @{b}NOM@{ub} FreeLayers -- libèrer les calques de l'image de fond (V1.5) @{b}SYNOPSIS@{ub} FreeLayers() @{b}FONCTION@{ub} Cette commande libère tous les calques liées à l'image de fond. Vous devez utiliser cette commande quand vous avez terminés avec les calques sur une image de fond parce qu'il libérera une certaine quantité de mémoire. Note: Les calques ne seront pas libérées quand vous afficher une nouvelle image de fond. Vous devez les libérer manuellement. Vous avez besoin @{"d'activer les calques" LINK EnableLayers} avant d'utiliser cette commande. Pour comprendre le fonctionnement des calques, lire @{"l'introduction aux calques" LINK LayersIntroduction}. @{b}INPUTS@{ub} aucun @ENDNODE @NODE InsertLayer "Guide Hollywood" @{b}NOM@{ub} InsertLayer -- insérer un nouveau calque(V1.5) @{b}SYNOPSIS@{ub} InsertLayer(pos, type, id, x, y[, hidden]) @{b}FONCTION@{ub} Cette commande insère un nouveau calque du type d'objet spécifié par le type et l'identification de l'objet spécifié par id à la position pos. Tous les calques suivants seront déplacés vers le bas dans la liste de calque et ils obtiendront une nouvelle identification. Le nouveau calque sera également affichée à la position spécifié par x et y. Les types d'objet suivants sont actuellement supportés: #BRUSH - insérer une brosse spécifié par id à x, y #TEXTOBJECT - insérer un objet textes spécifié par id à x, y #ANIM - insérer une animation spécifié par id à x, y (V2.0) Depuis Hollywood 1.9 vous pouvez spécifier l'argument optionnel hidden, qui insérera un calque cachée que vous pouvez rendre visible par la suite en utilisant @{"ShowLayer()" LINK ShowLayer} ou @{"ShowLayerFX()" LINK ShowLayerFX}. Vous avez besoin @{"d'activer les calques" LINK EnableLayers} avant d'utiliser cette commande. Pour comprendre le fonctionnement des calques, lire @{"l'introduction aux calques" LINK LayersIntroduction}. @{b}INPUTS@{ub} pos - position désirée pour lecalque type - type d'objet à insérer (voir la liste ci-dessus) id - identification de l'objet à insérer x - nouvelle position en x pour le calque y - nouvelle position en y pour le calque hidden - optionnel: TRUE si la calque doit être cachée (défaut: FALSE) (V1.9) @{b}EXEMPLE@{ub} EnableLayers() SetFillStyle(#FILLCOLOR) Box(0, 0, 100, 100, #RED) Circle(#CENTER, #CENTER, 50, #BLUE) TextOut(#RIGHT, #BOTTOM, "Hello World") InsertLayer(1, #BRUSH, 1, #CENTER, #CENTER) Le code ci-dessus insére la brosse 1 comme première calque. Ceci signifie que tous les autres calques seront repositionnées. Le rectangle rouge obtiendra maintenant la position de calque 2 (il était le calque 1 avant l'insertion de la brosse), le cercle bleu sera le calque 3 (il était le calque 2 avant l'insertion de la brosse) et "Hello World" serà la calque 4 (il était le calque 3 avant l'insertion de la brosse). @ENDNODE @NODE SetLayerTransparency "Guide Hollywood" @{b}NOM@{ub} SetLayerTransparency -- régler la transparence d'un calque (V1.5) @{b}SYNOPSIS@{ub} SetLayerTransparency(id, level) @{b}FONCTION@{ub} Cette commande peut être utilisé pour affecter des niveaux de transparence aux calques. Le niveau de transparence peut être de 0 à 255, où 0 signifie aucune transparence (paramètre par défaut du calque) et 255 totalement transparent qui signifie que vous ne le verrez pas le calque. Noter que c'est juste une autre méthode par rapport à @{"SetAlphaIntensity()" LINK SetAlphaIntensity} où 255 définie aucune transparence et 0 totalement transparent. Depuis Hollywood 2.0, le niveau peut également contenir une chaîne contenant une spécification en pourcentage, par exemple "50%". Note: Les calculs de transparence prennent un certain temps et peuvent être lent sur les ordinateurs 68k. Par conséquent n'utilisez pas cette commande si votre ordinateur est trop lent. Vous avez besoin @{"d'activer les calques" LINK EnableLayers} avant d'utiliser cette commande. Pour comprendre le fonctionnement des calques, lire @{"l'introduction aux calques" LINK LayersIntroduction}. @{b}INPUTS@{ub} id - identification ou nom du calque level - niveau de transparence à appliquer (0 à 255 ou indication en pourcentage) @{b}EXEMPLE@{ub} EnableLayers() ; ne pas afficher le texte, ajoutent juste un calque SelectBGPic(1) TextOut(#RIGHT, #BOTTOM, "Hello World") EndSelect ; maintenant il sera affiché ! SetLayerTransparency(1, 128) Le code ci-dessus créé le calque 1 (texte "Hello World") et le fait apparaître avec une transparence de 50% (= 128). @ENDNODE @NODE SetLayerTint "Guide Hollywood" @{b}NOM@{ub} SetLayerTint -- régler la luminositée sur un calque (V2.0) @ {b} AS@ ANCIEN CONNU {ub} SetLayerLight (V1.5) @{b}SYNOPSIS@{ub} SetLayerTint(id, tintcolor, tintlevel) @{b}FONCTION@{ub} Cette commande peut être utilisé pour teinter un calque avec une couleur spécifié à un niveau donné. C'est utile si vous voulez éclaircir le calque ((utilisez @{"#WHITE" LINK RGBInfo} dans tintcolor) ou pour l'assombrir (utilisez @{"#BLACK" LINK RGBInfo} dans tintcolor)). Naturellement, vous pouvez également utiliser d'autres couleurs. Le niveau s'échelonne de 0 à 255 là où 0 ne signifie aucune teinture (paramètre par défaut du calque) et 255 pour teinter totalement, le calque apparaîtra entièrement dans la couleur spécifié. Depuis Hollywood 2.0, tintlevel peut également contenir une chaîne contenant une spécification en pourcentage, par exemple "50%". Note: Les calculs de teinte prennent un certain temps et peuvent être lent sur les ordinateurs 68k. Par conséquent n'utilisez pas cette commande si votre ordinateur est trop lent. Vous avez besoin @{"d'activer les calques" LINK EnableLayers} avant d'utiliser cette commande. Pour comprendre le fonctionnement des calques, lire @{"l'introduction aux calques" LINK LayersIntroduction}. @{b}INPUTS@{ub} id - identification ou nom du calque tintcolor - @{"Couleur RGB" LINK RGBInfo} à utiliser pour la teinture tintlevel - niveau de teinte à appliquer (0 à 255 ou spécification en pourcentage) @{b}EXEMPLE@{ub} EnableLayers() DisplayBrush(1, #CENTER, #CENTER) SetLayerTint(1, #BLACK, 128) Le code ci-dessus assombri le calque 1 (= brosse 1) avec taux 50% (= 128). @ENDNODE @NODE TintBrush "Guide Hollywood" @{b}NOM@{ub} TintBrush -- teinter une brosse (V1.5) @{b}SYNOPSIS@{ub} TintBrush(id, color, level) @{b}FONCTION@{ub} cette commande teinte la brosse spécifié par id avec une @{"couleur RGB" LINK RGBInfo} spécifié dans color à un niveau indiqué par level qui s'échelonne de 0 à 255. Depuis Hollywood 2.0, le niveau peut également contenir une chaîne contenant une spécification en pourcentage, par exemple "50%". @{b}INPUTS@{ub} id - identification de la brosse à teinter color - @{"Couleur RGB" LINK RGBInfo} à utiliser pour la teinture level - niveau de teinte à appliquer (0 à 255 ou spécification en pourcentage) @{b}EXEMPLE@{ub} TintBrush(1, #RED, 128) Le code ci-dessus rend la brosse numéro 1 une apparence rouge. @ENDNODE @NODE ReplaceColors "Guide Hollywood" @{b}NOM@{ub} ReplaceColors -- changer les couleurs dans une brosse (V1.5) @{b}SYNOPSIS@{ub} ReplaceColors(id, colors) @{b}FONCTION@{ub} Cette commande scanne le tableau de couleur que vous spécifiez et remplace chaque couleur avec une autre couleur que vous devez également spécifier. le tableau de couleur doit être organisé de la manière suivante: rechercher la couleur 1, remplacer la couleur 1, Rechercher la couleur 2, remplacer la couleur 2, etc... @{b}INPUTS@{ub} id - identification de la brosse à utiliser colors - tableau de couleur qui décrit avec qu'elle couleur est à remplacer @{b}EXEMPLE@{ub} ReplaceColors(1, {#BLACK, #WHITE, #RED, #GREEN}) Ce code remplace tous les pixels noirs dans la brosse 1 par des pixels blancs et tous les pixels rouges par des pixels verts @ENDNODE @NODE BrushToGray "Guide Hollywood" @{b}NOM@{ub} BrushToGray -- convertir une brosse en gris(V1.5) @{b}SYNOPSIS@{ub} BrushToGray(id) @{b}FONCTION@{ub} cette commande convertit la brosse spécifié par id en gris. Si la brosse est grande, la conversion pourrait prendre un certain temps. @{b}INPUTS@{ub} id - identification de la brosse à convertir @{b}EXEMPLE@{ub} BrushToGray(1) Converti la brosse en gris. @ENDNODE @{b}NOM@{ub} MixBrush -- mélanger 2 brosses(V1.5) @{b}SYNOPSIS@{ub} MixBrush(brush1, brush2, level) @{b}FONCTION@{ub} Cette commande mélange brush2 dans brush1 au niveau spécifié par level. L'argument level spécifie le niveau de mélange qui s'échelonne de 0 à 255. Le canal alpha et les caractéristiques de masque de la deuxième brosse seront également pris en compte. Depuis Hollywood 2.0, level peut également être contenir de chaîne contenant une spécification en pourcentage, par exemple "50%". @{b}INPUTS@{ub} brush1 - brosse source brush2 - brosse à mélanger level - niveau de mélange à appliquer (0 à 255 ou spécification en pourcentage) @{b}EXEMPLE@{ub} MixBrush(1, 2, 128) Le code ci-dessus mélange les brosses 2 et 1 à un taux de 50% (= 128). @ENDNODE @NODE InvertBrush "Guide Hollywood" @{b}NOM@{ub} InvertBrush -- inverser les couleurs d'une brosse(V1.5) @{b}SYNOPSIS@{ub} InvertBrush(id) @{b}FONCTION@{ub} Cette commande inverse les couleurs de la brosse spécifié par id, se qui signifie que toutes les couleurs seront remplacées par leurs compléments (le blanc deviendra le noir, bleu deviendra jaune, etc...). @{b}INPUTS@{ub} id - brosse à inverser les couleurs @{b}EXEMPLE@{ub} InvertBrush(1) Le code ci-dessus inverse les couleurs de la brosse 1. @ENDNODE @NODE FlipBrush "Guide Hollywood" @{b}NOM@{ub} FlipBrush -- renverser une brosse (V1.5) @{b}SYNOPSIS@{ub} FlipBrush(id, xflip) @{b}FONCTION@{ub} Cette commande renverse (miroirs) la brosse spécifié par id si xflip est réglé sur TRUE , la brosse sera renversé dans horyzontalement autrement il sera renversé verticalement. @{b}INPUTS@{ub} id - brosse à renverser xflip - TRUE pour un renversement horizontale (x), FALSE pour un renversement verticale (y) @{b}EXEMPLE@{ub} FlipBrush(1, TRUE) Le code ci-dessus renverse la brosse horizontalement. @ENDNODE @NODE RotateBrush "Guide Hollywood" @{b}NOM@{ub} RotateBrush -- pivoter une brosse (V1.5) @{b}SYNOPSIS@{ub} RotateBrush(id, angle[, factorx, factory, smooth]) @{b}FONCTION@{ub} Cette commande tourne la brosse spécifié par id d'un angle spécifié par angle (en degrés). Un angle positif pivote la brosse dans le sens inverse des aiguilles d'une montre, un angle négatif pivote la brosse dans le sens des aiguilles d'une montre. Depuis Hollywood 2.5, cette commande peut également redimensionner la brosse tout en la pivotant (plus communément appelé roto-zoom). Ceci est effectué en une seule fois, donc la qualité visuel de l'image généré est supérieur à celle que génére les commandes @{"ScaleBrush()" LINK ScaleBrush} et RotateBrush(). Si vous voulez avoir la brosse redimensionné avec une rotation, indiquez simplement deux facteurs de redimensionnement comme factorx et factory. Ces deux facteurs sont des nombres à virgule flottante qui représente un pourcentage de zoom (1 correspond à 100%, 0.5 à 50%, 1.5 à 150% etc.) De plus, vous pouvez choisir d'avoir des graphismes redimensionnés et/ou pivotés interpolé en indiquant TRUE dans l'argument smooth. Les graphismes seront alors redimensionné/pivoté en utilisant l'anti-aliasing. Note: - Si vous pivotez une brosse, par exemple d'un angle de 45 degrés et que votre brosse n'a pas de masque, Hollywood crééra automatiquement un masque pour cette brosse parce que le commande de rotation mène habituellement à certains endroit inutilisés dans la brosse. Si votre brosse a un masque, alors Hollywood le pivotera également. - Vous ne devez pas faire pivoter une brosse plusieurs fois d'affilé sous peine d'avoir des perte de données graphiques. Vous devez toujours utiliser la brosse originel en créant pluseurs variante de rotation de brosse, par exemple si vous pivotez une brosse de 45 degrés et que vous voulez le pivoter en arrière de -45 degrés, la brosse générée ne sera pas de la même qualité que l'original. @{b}INPUTS@{ub} id - brosse à pivoter angle - angle de rotation en degrés factorx - optionnel: facteur de rediemnsionnement sur l'axe des abscisses (défaut à 1 se qui signifie aucun redimensionnement en x) (V2.5) factory - optionnel: facteur de rediemnsionnement sur l'axe des ordonnées (défaut à 1 se qui signifie aucun redimensionnement en x) (V2.5) smooth - optionnel: si oui ou non l'anti-aliasing doit être utilisé lors de la rotation (V2.5) @ENDNODE @NODE ScaleBGPic "Guide Hollywood" @{b}NOM@{ub} ScaleBGPic -- redimensionner une image de fond (V1.5) @{b}SYNOPSIS@{ub} ScaleBGPic(id, width, height[, smooth]) @{b}FONCTION@{ub} Cette commande redimensionne l'image de fond spécifié par id à la largeur et la hauteur spécifié par width et height. Vous ne pouvez pas utiliser cette commande avec l'image de fond qui est actuellement affichée. Si vous voulez changer la taille de cette image, vous devrez d'abord changer la taille de l'écran en utilisant @{"ChangeDisplaySize()" LINK ChangeDisplaySize}. Hollywood garde l'image originelle de chaque image de fond de sorte que vous ne devez pas faire cela. Chaque redimensionnement effectué avec ScaleBGPic() est créé avec l'image originale et pas avec une variante déjà redimensionné (contrairement à @{"ScaleBrush()" LINK ScaleBrush}). L'image originale sera seulement effacée que si vous modifiez le contenu de l'image de fond en utilisant @{"SelectBGPic()" LINK SelectBGPic}. Nouveau dans V2.0 : Vous pouvez indiquer #KEEPASPRAT en tant que la largeur ou hauteur. Hollywood évaluerà la taille automatiquement grâce au ratio de l'image de fond (hauteur/largeur). Depuis Hollywood 2.0, la largeur et la hauteur peuvent également être une chaîne contenant une indication en pourcentage, par exemple "50%". Depuis Hollywood 2.5 vous pouvez choisir d'avoir les images redimensionnées interpolé en indiquant TRUE dans l'argument smooth. Les images seront alors redimensionnées en utilisant l'anti-aliasing. @{b}INPUTS@{ub} id - image de fond à redimensionner width - nouvelle largeur pour l'image de fond height - nouvelle hauteur pour l'image de fond smooth - optionnel: si oui ou non le redimensionnement doit être effectué avec l'anti-aliasing (V2.5) @ENDNODE @NODE MoveLayer "Guide Hollywood" @{b}NOM@{ub} MoveLayer -- déplacer un calque de a à b (V1.9) @{b}SYNOPSIS@{ub} MoveLayer(id, xa, ya, xb, yb[, table]) @{b}FONCTION@{ub} Cette commande déplace (défilement) le calque spécifié par id doucement de l'emplacement spécifié par xa, ya à l'emplacement spécifié par xb, yb. Vous pouvez indiquer la constante spéciale #USELAYERPOSITION comme une des coordonnées. Hollywood utiliserà la position actuelle du calque. D'autres options de configuration sont possibles en utilisant l'argument optionnel table. Vous pouvez spécifier la vitesse de mouvement, effet spécial et si oui ou non le mouvement sera asynchrone. Voir la documentation de la commande @{"MoveBrush()" LINK MoveBrush} pour plus d'information. Vous avez besoin @{"d'activer les calques" LINK EnableLayers} avant d'utiliser cette commande. Pour mieux comprendre le fconctionnement des calques avec Hollywood, lire @{"introduction aux calques" LINK LayersIntroduction}. @{b}INPUTS@{ub} id - identification ou nom du calque à utiliser xa - position x de la source ya - position y de la source xb - position x de la destination yb - position y de la destination table - optionnel: davantage de configuration pour ce mouvement @{b}EXEMPLE@{ub} MoveLayer(5,#LEFTOUT,#CENTER,#RIGHTOUT,#CENTER) Déplace le calque 5 de la gauche extérieur vers la droite extérieure de l'écran et le centres verticalement. ---------------------------- MoveLayer(4, #USELAYERPOSITION, #USELAYERPOSITION, #LEFTOUT, #CENTER) Déplace le calque 4 de sa position actuelle vers l'extérieur de l'écran. @ENDNODE @NODE ShowLayerFX "Guide Hollywood" @{b}NOM@{ub} ShowLayerFX -- afficher un calque cachée avec un effet de transition (V1.9) @{b}SYNOPSIS@{ub} ShowLayerFX(id[, table]) [V4.0] ShowLayerFX(id[, type, speed, arg]) [old syntax until version 3.1] @{b}FONCTION@{ub} Cette commande est une version amélioré de la commande @{"ShowLayer()" LINK ShowLayer}. Il affiche le calque cachée spécifié par id et utilise un des nombreux effets de transition d'Hollywood. Vous pouvez également spécifier la vitesse de la transition et un argument optionnel. Depuis Hollywood 4.0 Cette commande utilise une nouvelle syntaxe avec juste un tableau comme argument optionnel. L'ancienne syntaxe est encore supportée pour des raisons de compatibilité. L'argument optionnel table peut être utilisé pour configurer l'effet de transition. Les options suivantes sont possibles : Type : Spécifie l'effet souhaité pour la transition. Pour une liste de tous les effets de transition supporté, voir la documentation de la commande @{"DisplayTransitionFX()" LINK DisplayTransitionFX} (défaut: #RANDOMEFFECT) speed: Spécifie la vitesse désirée pour la transition. Plus la valeur sera élevé, plus la vitesse de l'effet de transition sera rapidement affiché. (défaut: #NORMALSPEED) Parameter: Quelques effets de transition reçoivent un paramètre supplémentaire. Ils peuvent être spécifié ici. (défauts: #RANDOMPARAMETER) Async : Vous pouvez utiliser cet indicateur pour créer un objet asynchrone pour cette transition. Si vous indiquez TRUE, ShowLayerFX() sera immédiatement quitter, renvoyant une prise en charge d'affichage asynchrone de l'objet que vous pouvez alors afficher en utilisant AsyncDrawFrame(). Lire la documentation de @{"AsyncDrawFrame()" LINK AsyncDrawFrame} pour plus d'information sur l'affichage d'objets asynchrone. Vous avez besoin @{"d'activer les calques" LINK EnableLayers} avant d'utiliser cette commande. Pour comprendre le fonctionnement des calques, lire @{"l'introduction aux calques" LINK LayersIntroduction}. @{b}INPUTS@{ub} id - identificateur ou nom du calque cachée à afficher table - optionnel: tableau de configuration pour les effets de transition @{b}EXEMPLE@{ub} ShowLayerFX(5, #CROSSFADE) ; ancienne syntaxe OU ShowLayerFX(5, {Type = #CROSSFADE}) ; nouvelle syntaxe Le code ci-dessus affiche le calque 5 avec un effet de transition crossfade. @ENDNODE @NODE Red "Guide Hollywood" @{b}NOM@{ub} Red -- obtenir la partie rouge d'une couleur (V1.9) @{b}SYNOPSIS@{ub} r = Red(color) @{b}FONCTION@{ub} Cette commande renvoie la composante rouge de 8 bits d'une couleur dans le @{"format RGB" LINK RGBInfo}. @{b}INPUTS@{ub} color - couleur d'entrée dans le @{"format RGB" LINK RGBInfo}. @{b}RESULTAT@{ub} r - composant rouge de la couleur @{b}EXEMPLE@{ub} r = Red($24C0C0) Le code ci-dessus renverra $24 qui est la composante rouge de la couleur. @ENDNODE @NODE Green "Guide Hollywood" @{b}NOM@{ub} Green -- obtenir la partie verte d'une couleur (V1.9) @{b}SYNOPSIS@{ub} g = Green(color) @{b}FONCTION@{ub} Cette commande renvoie la composante verte de 8 bits d'une couleur dans le @{"format RGB" LINK RGBInfo}. @{b}INPUTS@{ub} color - couleur d'entrée dans le @{"format RGB" LINK RGBInfo}. @{b}RESULTAT@{ub} g - composante verte de la couleur @{b}EXEMPLE@{ub} g = Green($24C0C0) Le code ci-dessus renverra $C0 qui est la composante verte de la couleur. @ENDNODE @NODE Blue "Guide Hollywood" @{b}NOM@{ub} Blue -- obtenir la partie bleu d'une couleur (V1.9) @{b}SYNOPSIS@{ub} b = Blue(color) @{b}FONCTION@{ub} Cette commande renvoie la composante bleu de 8 bits d'une couleur dans le @{"format RGB" LINK RGBInfo}. @{b}INPUTS@{ub} color - couleur d'entrée dans le @{"format RGB" LINK RGBInfo}. @{b}RESULTAT@{ub} b - composante bleue de la couleur @{b}EXEMPLE@{ub} b = Blue($C0C024) Le code ci-dessus renverra $C0 qui est la composante bleue de la couleur. @ENDNODE @NODE RGB "Guide Hollywood" @{b}NOM@{ub} RGB -- composer une couleur (V1.9) @{b}SYNOPSIS@{ub} color = RGB(red, green, blue) @{b}FONCTION@{ub} Cette commande compose une @{"couleur RGB" LINK RGBInfo} en mélangeant les trois couleurs fondamentales rouge, vert et bleu. Vous devez spécifier une intensité de 0 à 255 pour chaque couleur fondamentale. @{b}INPUTS@{ub} red - intensité rouge (0-255) green - intensité verte (0-255) blue - intensité bleue (0-255) @{b}RESULTAT@{ub} color - couleur en RGB @{b}EXEMPLE@{ub} color = RGB(255, 255, 255) ; blanc color = RGB(255, 0, 0) ; rouge color = RGB(255, 255, 0) ; jaune (rouge + vert) color = RGB(255, 0, 255) ; magenta (vert + bleu) @ENDNODE @NODE HideLayerFX "Guide Hollywood" @{b}NOM@{ub} HideLayerFX -- cacher un calque avec un effet de transition (V1.9) @{b}SYNOPSIS@{ub} HideLayerFX(id[, table]) [V4.0] HideLayerFX(id[, type, speed, arg]) [ancienne syntaxe jusqu'à la version 3.1] @{b}FONCTION@{ub} Cette commande est une version améliorée de la commande @{"HideLayer()" LINK HideLayer}. Il cache le calque spécifié par id et utilise un des nombreux effets de transition d'Hollywood. Vous pouvez également indiquer la vitesse de la transition et un argument optionnel. Depuis Hollywood 4.0 cette commande utilise une nouvelle syntaxe avec juste un tableau comme argument optionnel. L'ancienne syntaxe est encore supportée pour des raisons de compatibilité. L'argument optionnel table peut être utilisé pour configurer l'effet de transition. Les options suivantes sont possibles: Type : Spécifie l'effet souhaité pour la transition. Pour une liste de tous les effets de transition supporté, voir la documentation de la commande @{"DisplayTransitionFX()" LINK DisplayTransitionFX} (défaut: #RANDOMEFFECT) speed : Spécifie la vitesse désirée pour la transition. Plus la valeur sera élevé, plus la vitesse de l'effet de transition sera rapidement affiché. (défaut: #NORMALSPEED) Parameter: Quelques effets de transition reçoivent un paramètre supplémentaire. Ils peuvent être spécifié ici. (défaut: #RANDOMPARAMETER) Async : Vous pouvez utiliser cet indicateur pour créer un objet asynchrone pour cette transition. Si vous indiquez TRUE, HideLayerFX() sera immédiatement quitter, renvoyant une prise en charge d'affichage asynchrone de l'objet que vous pouvez alors afficher en utilisant AsyncDrawFrame(). Lire la documentation de @{"AsyncDrawFrame()" LINK AsyncDrawFrame} pour plus d'information. Vous avez besoin @{"d'activer les calques" LINK EnableLayers} avant d'utiliser cette commande. Pour comprendre le fonctionnement des calques, lire @{"l'introduction aux calques" LINK LayersIntroduction}. @{b}INPUTS@{ub} id - identificateur ou nom du calque à cacher table - optionnel: tableau de configuration pour les effets de transition @{b}EXEMPLE@{ub} HideLayerFX(5, {Type = #CROSSFADE}) ; nouvelle syntaxe OU HideLayerFX(5, #CROSSFADE) ; ancienne syntaxe Le code ci-dessus cache le calque 5 avec un effet de transition crossfade. @ENDNODE @NODE Polygon "Guide Hollywood" @{b}NOM@{ub} Polygon -- Tracer un polygone (V1.9) @{b}SYNOPSIS@{ub} Polygon(x, y, vertices, count[, color, rotate]) @{b}FONCTION@{ub} Cette commande trace un polygone depuis un tableau de points de sommet défini par vertices. spécifie un tableau depoint aux coordonnées x et y, qui sont utilisées pour tracer le polygone. L'argument count spécifie combien de points de sommet compte votre polygone. De plus, vous devez spécifier la couleur du polygone spécifié par color (dans le format RVB). Le polygone sera tracé dans le style de forme spécifié en utilisant @{"SetFormStyle()" LINK SetFormStyle} et sera rempli selon la configuration sélectionnée avec @{"SetFillStyle()" LINK SetFillStyle}. N'oublier pas également que le dernier point de sommet doit fermer le polygone, c'est-à dire que le dernier point doit être identique au premier point. Les points de sommet peuvent être négatifs et/ou spécifiés par un nombre à virgule flottante afin d'obtenir une meilleure précision. Hollywood n'arrondira pas ces nombres à virgules flottantes avant qu'elle ait fait le tramage final. Nouveau dans Hollywood 2.0: La couleur peut également être une @{"valeur ARGB" LINK ARGBInfo} pour l'alpha-blended. Dans Hollywood 2.5 l'argument de rotation optionnel a été ajouté. Grâce à cet argument vous pouvez pivoter un polygone. Spécifier simplement un angle dans la fourchette de 0 et 360 degrés et polygon() tracera un polygone pivoter de l'angle définie. Cet argument est par défaut à 0 qui ne signifie aucune rotation. @{b}INPUTS@{ub} x - décalage en x du polygone sur l'écran y - décalage en y du polygone sur l'écran vertices - un tableau des points d'intersection qui décrivent le polygone count - nombre de points d'intersection dans le tableau color - optionnel: couleur en @{"RGB" LINK RGBInfo} ou @{"ARGB" LINK ARGBInfo} (défaut: #BLACK) la couleur est optionnelle parce qu'elle n'est pas exigé quand vous généré dans un masque ou un canal alpha rotate - optionnel: rotation désirée pour ce polygone en degrés (V2.5) @{b}EXEMPLE@{ub} v = {} v[0] = 0 ;X1 v[3] = 0 ;Y2 v[4] = 100 ;X3 v[5] = 100 ;Y3 v[6] = 0 ;X4 v[7] = 100 ;Y4 Polygon(#CENTER, #CENTER, v, 4, #RED) Le code ci-dessus trace un triangle rouge au centre de l'écran. --- Polygon(#CENTER, #CENTER, v, 4, #RED, 45) Le code ci-dessus trace un triangle pivoté de 45 degrés. @ENDNODE @NODE VWait "Guide Hollywood" @{b}NOM@{ub} VWait -- attendre un vide vertical @{b}SYNOPSIS@{ub} VWait () @{b}FONCTION@{ub} Cette commande attend le prochain vide vertical pour commencer. Vous devez plutôt utiliser @{"SetInterval()" LINK SetInterval} pour votre calage. @{b}INPUTS@{ub} aucun @ENDNODE @NODE MoveDisplay "Guide Hollywood" @{b}NOM@{ub} MoveDisplay -- déplacer l'affichage à une nouvelle position de l'écran (V2.0) @{b}SYNOPSIS@{ub} MoveDisplay(x, y) @{b}FONCTION@{ub} Cette commande déplace l'affichage à une nouvelle position spécifié par x et y. Vous pouvez également utiliser les constantes spéciales de coordonnée. Pour vérifier si les positions x et y sont valides, vous pouvez interroger les attributs #ATTRMAXWIDTH et #ATTRMAXHEIGHT avec @{"GetAttribute()" LINK GetAttribute}. La position initiale de l'écran peut être réglée avec la commande préprocesseur @{"@DISPLAY" LINK atDISPLAY}. @{b}INPUTS@{ub} x - nouvelle position en x de l'écran y - nouvelle position en y de l'écran @{b}EXEMPLE@{ub} MoveDisplay(#LEFT, #TOP) Le code ci-dessus déplace l'affichage en Haut à Gauche de l'écran @ENDNODE @NODE SelectMask "Guide Hollywood" @{b}NOM@{ub} SelectMask -- sélectionner le masque d'une brosse comme périphérique de sortie vidéo (V2.0) @{b}SYNOPSIS@{ub} SelectMask(id) @{b}FONCTION@{ub} Cette commande sélectionne le masque de la brosse spécifié par id en tant que périphérique de sortie vidéo. Ceci signifie que toutes les données graphiques qui doivent être affiché seront enregistrés dans se masque. Les masques sont utilisés pour la transparence d'une brosse et ne transmettent aucune information de couleur. Chaque pixel dans un masque peut seulement avoir deux valeurs différentes : 1, qui signifie que ce pixel est visible et 0 quand le pixel est invisible. Par conséquent vous devez informer Hollywood, si les commandes de traçages doivent afficher les pixel visibles (1) ou les pixel invisibles (0) dans le masque. Ceci est effectué en utilisant la commande @{"SetMaskMode()" LINK SetMaskMode} . L'argument color aux autres commandes de Hollywood (comme @{"Box()" LINK Box} ou @{"Circle()" LINK Circle}) excepté, qu'elle est superflu quand vous généré des masques. Vous devez seulement utiliser SetMaskMode(). Si la brosse que vous spécifiez dans id n'a pas de masque, alors il sera automatiquement créé quand vous exécuterez une commande qui affiche se masque. Le masque créé sera alors opaque. Pour annuler le mode de rendu de masque et remettre la sortie vidéo à l'écran vous devez juste exécuter la commande @{"EndSelect()" LINK EndSelect} Si vous n'avez plus besoin du masque, vous pouvez l'effacer de la brosse en utilisant @{"SetBrushTransparency()" LINK SetBrushTransparency} avec l'argument #NOTRANSPARENCY. Ou simplement utiliser @{"DeleteMask()" LINK DeleteMask}. Vous ne pouvez pas utiliser les liens de brosse avec cette commande parce que les données graphiques de la brosse spécifiée par id seront modifiés. Il est également impossible d'exécuter les commandes qui changent les dimensions de la brosse qui est actuellement utilisé comme périphérique de sortie, par exemple vous ne pouvez pas exécuter @{"ScaleBrush()" LINK ScaleBrush} pour redimensionner la brosse qui est le périphérique de sortie actuellement utilisé. Seul les commandes qui affichent ou traces des graphismes directement à l'écran peuvent être utilisées après SelectMask(). Vous ne pouvez pas utiliser les commandes d'animations comme @{"MoveBrush()" LINK MoveBrush} ou @{"DisplayBrushFX()" LINK DisplayBrushFX} lorsque SelectMask() est activé. Noter que les brosses ne peuvent pas avoir en même temps un masque et un canal alpha. Seul un réglage de transparence est possible. Donc, si vous utilisez cette commande avec une brosse qui a un canal alpha, ce canal alpha sera effacé. @{b}INPUTS@{ub} id - brosse dont le masque sera utilisé comme périphérique de sortie vidéo @{b}EXEMPLE@{ub} w = GetAttribute(#BRUSH, 1, #ATTRWIDTH) h = GetAttribute(#BRUSH, 1, #ATTRHEIGHT) SetFillStyle(#FILLCOLOR) SelectMask(1) ; sélectionner le masque comme périphérique de sortie vidéo SetMaskMode(#MASKINVISIBLE) ; toutes les commandes d'affichage ou de traçage redront les pixel invisibles Cls ; effacer toutes les pixel, la brosse est complétement transparente SetMaskMode(#MASKVISIBLE) ; toutes les commandes d'affichage ou de traçage redront les pixel visibles Box(0, 0, w, h, 0, 20) ; trace un rectangle avec les bords arrondis EndSelect ; sélectionner de nouveau l'écran comme périphérique de sortie vidéo Le code ci-dessus génére un rectangle avec les bords arrondis dans le masque de la brosse 1. Quand vous affichez la brosse 1, il apparaît avec les bords arrondis. @ENDNODE @NODE SetMaskMode "Guide Hollywood" @{b}NOM@{ub} SetMaskMode -- définir le mode de rendu des masques (V2.0) @{b}SYNOPSIS@{ub} SetMaskMode(mode) @{b}FONCTION@{ub} Cette commande peut être utilisé pour définir le mode de rendu quand @{"SelectMask()" LINK SelectMask} est activié. L'argument mode peut être #MASKVISIBLE ou #MASKINVISIBLE. Si vous sélectionnez le mode visible, toutes les commandes d'affichage ou de traçage rendront les pixel visibles dans le masque, sinon les pixel seront invisibles. Evidemment, un masque ne transmet aucune information de couleur mais seulement deux indicateurs par pixel (visible ou invisible). Depuis Hollywood 4.0, les nouveaux modes de masque suivant sont supportés: #MASKVANILLACOPY : les données de masquage de l'image source seront intégralement copiées à la destination. #MASKAND : Les données de masquage de l'image source seront copiées au masque de destination en utilisanrt l'opérateur logique AND sur chacun des Pixels. #MASKOR : Les données de masquage de l'image source seront copiées au masque de destination en utilisanrt l'opérateur logique OR sur chacun des Pixels. #MASKXOR : Les données de masquage de l'image source seront copiées au masque de destination en utilisanrt l'opérateur logique XOR sur chacun des Pixels. Ci-dessous, un tableau résumant les différents modes de masquage. Noter que #MASKVISIBLE, #MASKINVISIBLE, et #MASKVANILLACOPY sont indépendant des données de masquage de la destination. Les données de masquage de la destination est seulement pris en compte par #MASKAND, #MASKOR, et #MASKXOR. ================================================================== = Source | Dest | VISIBLE | INVISIBLE | VANILLA | AND | OR | XOR = =----------------------------------------------------------------= = 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 = = 0 | 1 | 0 | 0 | 0 | 0 | 1 | 1 = = 1 | 0 | 1 | 0 | 1 | 0 | 1 | 1 = = 1 | 1 | 1 | 0 | 1 | 1 | 1 | 0 = ================================================================== Voir la description de la commande @{"SelectMask()" LINK SelectMask}. @{b}INPUTS@{ub} mode - mode de génération de masque (voir ci-dessus) @{b}EXEMPLE@{ub} voir @{"SelectMask()" LINK SelectMask} @ENDNODE @NODE GetRealColor "Guide Hollywood" @{b}NOM@{ub} GetRealColor -- Connaître la représentation d'une couleur sur l'écran (V1.5) @{b}SYNOPSIS@{ub} color = GetRealColor(col) @{b}FONCTION@{ub} Cette commande retourne la couleur qui représente la couleur spécifié sur l'écran. Sur des écrans en 24 et 32 bits, la couleur retournée est toujours la même que la couleur que vous avez spécifiée. Sur 15 et 16 bits, la couleur retournée est légèrement différente de la couleur originelle dans la plupart des cas parce que ces écrans n'ont pas 16.7 millions de couleurs mais seulement 65536 (écrans de 16 bits) et 32768 (écrans 15-bit). Cette commande est la plupart du temps utilisée avec @{"ReadPixel()" LINK ReadPixel}. @{b}INPUTS@{ub} col - couleur pour trouver la représentation pour @{b}RESULTAT@{ub} color - couleur qui représente la couleur spécifié sur la sortie vidéo @{b}EXEMPLE@{ub} color = GetRealColor($FFFFFF) La couleur obtiendra les valeurs suivantes sur€¦ 1) écrans 24 et 32 bits : $FFFFFF 2) écrans 16 bits : $F8FCF8 3) écrans 15-bit : $F8F8F8 @ENDNODE @NODE NextFrame "Guide Hollywood" @{b}NOM@{ub} NextFrame -- afficher une nouvelle image d'une animation de calque (V2.0) @{b}SYNOPSIS@{ub} NextFrame(id[, x, y, frame]) @{b}FONCTION@{ub} Cette commande affiche une nouvelle image d'une animation de calque. Si vous omettez l'argument optionnel frame ou que voue le réglez à 0, NextFrame() afficherà la prochaine image de l'animtaion de calque. Si vous indiquez -1 dans l'argument frame, la dernière image sera affiché. Les arguments x et y peuvent être utilisés pour déplacer le calque à une nouvelle position tout en changeant l'image. Si vous n'avez pas besoin de ces 2 arguments de positions utiliser #USELAYERPOSITION qui garderà la position original de l'animation. Vous devez avoir les @{"calques activés" LINK EnableLayers} avant d'utiliser cette commande. Pour apprendre plus au sujet des caqlues, lire le chapitre @{"introduction au calque" LINK LayersIntroduction}. @{b}INPUTS@{ub} id - identificateur ou nom de l'animation de calque x - optionnel: nouvelle position en x du calque (défaut: #USELAYERPOSITION) y - optionnel: nouvelle position en y du calque (défaut: #USELAYERPOSITON) frame - optionnel: image à afficher (défauts à 0 ce qui signifie que la prochaine image de l'animation sera affichée) @{b}EXEMPLE@{ub} EnableLayers InsertLayer(1, #ANIM, 1, 0, #CENTER) For k = 0 To 400 Step 3 NextFrame(1, k, #USELAYERPOSITION) Wait(5) Next Joue l'animation 1 tout en la déplaçant de la position en x=0 à x=400. @ENDNODE @NODE CreateAnim "Guide Hollywood" @{b}NOM@{ub} CreateAnim -- créer une animation depuis une brosse (V2.0) @{b}SYNOPSIS@{ub} CreateAnim(id, brush, width, height, frames, fpr[, sx, sy]) @{b}FONCTION@{ub} Cette commande peut être utilisé pour créer une nouvelle animation depuis une brosse. Les images seront lus depuis la brosse spécifié et seront insérées dans une nouvelle animation. Vous devez indiquez la largeur et la hauteur des images aussi que le nombre d'images à lire depuis la brosse et combien d'images sont rangés dans une colonne. Éventuellement, vous pouvez définir une la position d'où dans la brosse la conversion commencera. Si la brosse source est transparente, la nouvelle animation aura également des zones transparentes. @{b}INPUTS@{ub} id - identificateur pour la nouvelle animation brush - brosse source width - largeur de chaque image de l'animation height - hauteur de chaque image de l'animation frames - le nombre d'images que contient l'animation fpr - combien d'images sont disponible dans une rangée; si le nombre est identique au nombre d'image, alors toutes les images doivent être dans la même rangée sx - optionnel: décalage en x dans la brosse source (défaut: 0) sy - optionnel: décalage en y dans la brosse source (défaut: 0) @ENDNODE @NODE CopyAnim "Guide Hollywood" @{b}NOM@{ub} CopyAnim -- copier une animation (V2.0) @{b}SYNOPSIS@{ub} CopyAnim(src, dst) @{b}FONCTION@{ub} Cette commande copie l'animation spécifié par src et créé une copie dans la nouvelle animation spécifié par dst. La nouvelle animation est indépendante de l'ancienne ainsi vous pouvez libérer l'animation après copie afin @{b}INPUTS@{ub} src - animation source dst - animation de destination @ENDNODE @NODE Collision "Guide Hollywood" @{b}NOM@{ub} Collision -- vérifier si deux objets se touche (V2.0) @{b}SYNOPSIS@{ub} bool = Collision(type, ...) bool = Collision(#BOX, x1, y1, width1, height1, x2, y2, width2, height2) bool = Collision(#BRUSH, id1, x1, y1, id2, x2, y2) bool = Collision(#LAYER, id1, id2) bool = Collision(#SPRITE, id1, id2) @{b}FONCTION@{ub} Cette commande contrôle si deux objets se touchent. Il y a plusieurs possibilités d'utilisation de cette commande selon le type de collision que vous indiquez. Les types de collision suivant sont actuellement supportés : #BOX : Vous devez spécifier la position et la taille de deux rectangles et Cette commande déterminera s'ils se touchent ou pas. C'est un rapide calcul mais il n'est probablement pas assez précis pour certaines méthodes. #BRUSH : Vérifie si les deux brosses spécifié par id1 et id2 se touchent s'ils sont affichées à x1 :y1 et x2 :y2. Les zones transparentes (masque ou canal alpha) des brosses sont respecté de sorte que vous obtenez un résultat précis au pixel près. #LAYER : Vérifie si les deux calques spécifiés par id1 et id2 se touchent. Si les calques ont des zones transparentes, elles seront respectées. Si vous utilisez ce type de collision, la gestion des calques doit être activé. #SPRITE : Vérifie si les deux sprite spécifiés par id1 et id2 se touchent. Si les sprites ont des zones transparentes, elles seront respectées. @{b}INPUTS@{ub} type - #BOX, #BRUSH, #SPRITE, ou #LAYER €¦ - les arguments optionnels dépendent du type spécifié (voir ci-dessus) @{b}RESULTAT@{ub} bool - TRUE il y a collision, sinon FALSE @{b}EXEMPLE@{ub} Box(10, 10, 100, 100, #RED) Box(70, 70, 100, 100, #BLUE) b = Collision(#BOX, 10, 10, 100, 100, 70, 70, 100, 100) Ceci renvoie TRUE parce que les rectangles se touchent. @ENDNODE @NODE SaveBrush "Guide Hollywood" @{b}NOM@{ub} SaveBrush -- sauvegarder une brosse dans un fichier (V2.0) @{b}SYNOPSIS@{ub} SaveBrush (identification, f$ [, transcolor, fmt, qualité]) @{b}FONCTION@{ub} Cette commande sauvegarde la brosse spécifiée par id dans le fichier spécifié par f$. Si vous spécifiez l'argument optionnel transcolor, toutes les zones transparentes dans la brosse seront remplis de cette couleur. L'argument fmt spécifie le format de sauvegarde désiré de l'image (défaut: #IMGFMT_BMP ce qui sauvegarde en image 24 Bit au format .BMP). Depuis Hollywood 2.5, vous pouvez également indiquer #IMGFMT_PNG comme format. SaveBrush() sauvegardera alors la brosse au format .PNG. Si la brosse a un canal alpha, ce canal alpha sera également sauvegarder dans l'image .PNG. Depuis Hollywood 4.0, vous pouvez également indiquer #IMGFMT_JPEG comme format. SaveBrush() sauvegardera alors la brosse au format .JPEG. Noter que Le format JPEG ne supporte pas les canaux alphas. Le paramètre optionnel quality vous permet de spécifier le niveau de qualité pour les images JPEG (les valeurs admissibles sont de 0 à 100 où 100 est la meilleure qualité). @{b}INPUTS@{ub} id - identification de la brosse à sauvegarder f$ - fichier de destination transcolor - optionnel: couleur à utiliser pour les zones transparentes (défaut: #BLACK) fmt - optionnel: format du fichier; #IMGFMT_BMP ou #IMGFMT_PNG (V2.5) ou #IMGFMT_JPEG (V4.0) (défaut: #IMGFMT_BMP) quality - optionnel: niveau de qualité pour le fichier image (seulement utilisé si fmt est #IMGFMT_JPEG) ; les valeurs admissibles sont de 0 à 100 où 100 signifie la meilleure qualité (défauts à 90) (V4.0) @ENDNODE @NODE SaveSnapshot "Guide Hollywood" @{b}NOM@{ub} SaveSnapshot -- effectuer une copie d'écran actuellement affiché (V2.0) @{b}SYNOPSIS@{ub} SaveSnapshot(f$[, mode, fmt, quality]) @{b}FONCTION@{ub} Cette commande effectue une copie d'écran et la sauvegarde dans un fichier spécifié par f$. L'argument mode spécifie quel zone sera copié. Ceci peut être #SNAPWINDOW, se qui signifie que seul la fenêtre Hollywood sera copié (avec les bords), #SNAPDISPLAY, se qui signifie que seul le contenu de l'écran sera copié ou #SNAPDESKTOP, se qui signifie que l'écran au complet sera copié. L'argument fmt spécifie lle format d'image désiré pour le fichier (défaut: #IMGFMT_BMP qui sauvegardera dans un fichier au format .BMP en 24 bit). Depuis Hollywood 2.5, vous pouvez également indiquer #IMGFMT_PNG comme format. SaveSnapshot() sauvegardera alors la copie d'écran comme image .PNG. Depuis Hollywood 4.0, vous pouvez également indiquer #IMGFMT_JPEG comme format. SaveBrush() sauvegardera alors la copie d'écran comme image JPEG. Le paramètre optionnel quality vous permet de spécifier le niveau de qualité pour l'image JPEG (les valeurs admissibles sont de 0 à 100 où 100 est la meilleure qualité). @{b}INPUTS@{ub} f$ - fichier de destination mode - optionnel: spécifie quel zone sera copié (défauts: #SNAPWINDOW) fmt - optionnel: format du fichier ; #IMGFMT_BMP ou #IMGFMT_PNG (V2.5) ou #IMGFMT_JPEG (V4.0) (défaut: #IMGFMT_BMP) quality - optionnel: niveau de qualité pour le fichier image (seulement utilisé si fmt est #IMGFMT_JPEG) ; les valeurs admissibles sont de 0 à 100 où 100 signifie la meilleure qualité (défauts à 90) (V4.0) @{b}EXEMPLE@{ub} SaveSnapshot("Ram:Snap.bmp") Sauvegarde une copie de la fenêtre Hollywood dans RAM:Snap.bmp. @ENDNODE @NODE SetLayerName "Guide Hollywood" @{b}NOM@{ub} SetLayerName -- affecter un nom à un calque (V2.0) @{b}SYNOPSIS@{ub} SetLayerName(id, name$) @{b}FONCTION@{ub} Vous pouvez utiliser cette commande pour affecter un nom à un calque spécifié par id. C'est très utile si vous avez plusieurs calques dont l'identification change continuellement (par exemple parce que vous retirez et ajoutez des calques). Si vous donnez des noms à vos calques, vous ne devez pas vous inquiéter sur leurs positions ou ils sont actuellement affichés. Vous pouvez facilement accéder à ces calques en utilisant leurs noms. Toutes les commandes qui accéptent l'identification de calque, accépteront également les noms. Noter que le nom d'un calque doit être unique dans le cache de calque d'une image de fond. Les noms de calque sont insensible au format des lettres, c.-à-d. " layer1 " est le même calque que " LAYER1 ". Pour découvrir quel id correspond à quel nom, utiliser l'attribut #ATTRLAYERID avec la commande @{"GetAttribute()" LINK GetAttribute} Vous avez besoin @{"d'activer les calques" LINK EnableLayers} avant d'utiliser cette commande. Pour comprendre le fonctionnement des calques, lire @{"l'introduction aux calques" LINK LayersIntroduction}. @{b}INPUTS@{ub} id - identification du calque à nommer name$ - nom désiré pour le calque @{b}EXEMPLE@{ub} EnableLayers() SetFillStyle(#FILLCOLOR) Box(0, 0, 100, 100, #RED) ; création du calque 1 Box(50, 50, 100, 100, #GREEN) ; création du calque 2 SetLayerName(1, "redbox") ; affecte un nom au calque 1 SetLayerName(2, "greenbox") ; affecte un nom au calque 2 SwapLayers("redbox", "greenbox") ; permutation, maintenant la boite verte est le calque 1 et la boite rouge est le calque 2 ShowLayer("redbox", #RIGHT, #BOTTOM) ; déplace le calque 2 en haut à droite ShowLayer("greenbox", #LEFT, #TOP) ; déplacer le calque 1 en haut à gauche Vous voyez qu'il est beaucoup plus facile d'utiliser des noms pour gérer les calques au lieu des id traditionnels qui sont relatifs à la position du calque. @ENDNODE @NODE Cls "Guide Hollywood" @{b}NOM@{ub} Cls -- effacer l'écran (V2.0) @{b}SYNOPSIS@{ub} Cls([color]) @{b}FONCTION@{ub} Cette commande efface rapidement le périphérique de sortie vidéo. Son comportement dépend de ce qui est sélectionné comme périphérique de sortie vidéo. Si le périphérique de sortie est l'écran, tous sera effacé ainsi que les calques et sprites L'argument color n'est pas utilisé dans ce cas. Si le périphérique de sortie est une brosse, il sera effacé avec la couleur spécifié. Si le périphérique de sortie est une image de fond, c.-à-d. que @{"SelectBGPic()" LINK SelectBGPic} est activé, tous les calques de cette image seront enlevés. L'argument color n'est pas utilisé dans ce cas. Si le périphérique de sortie est un masque, Cls() libérera les Pixels en utilisant le mode qui a été installé avec @{"SetMaskMode()" LINK SetMaskMode}. L'argument color n'est pas utilisé dans ce cas. Si le périphérique de sortie est un canal alpha, Cls() remplira les Pixels dont l'intensité a été spécifié en utilisant @{"SetAlphaIntensity()" LINK SetAlphaIntensity}. l'argument color n'est pas utilisé dans ce cas. @{b}INPUTS@{ub} color - optionnel: @{"couleur RGB" LINK RGBInfo} (défaut: #BLACK); seulement nécessaire une fois utilisé quand @{"SelectBrush()" LINK SelectBrush} est activé @ENDNODE @NODE InvertMask "Guide Hollywood" @{b}NOM@{ub} InvertMask -- inverser un masque de brosse (V2.0) @{b}SYNOPSIS@{ub} InvertMask(id) @{b}FONCTION@{ub} Cette commande inverse le masque de la brosse spécifiée par id. Cela signifie que toutes les zones qui étaient précédemment transparentes, deviendront opaques et les zones qui étaient opaques précédemment, deviendront transparentes. @{b}INPUTS@{ub} id - brosse dont le masque doit être inversé @ENDNODE @NODE InvertAlphaChannel "Guide Hollywood" @{b}NOM@{ub} InvertAlphaChannel -- inverser le canal alpha d'une brosse (V2.0) @{b}SYNOPSIS@{ub} InvertAlphaChannel(id) @{b}FONCTION@{ub} Cette commande inverse le canal alpha de la brosse spécifiée par id. Ceci signifie que la transparence pour chaque Pixel est ré-évaluer. Si un Pixel était précédemment transparent à 80%, alors il le sera seulement à 20% après une inversion et les Pixels qui étaient transparent à 20% seront transparent à 80% après l'inversion. @{b}INPUTS@{ub} id - brosse dont le canal alpha doit être inversé @ENDNODE @NODE FloodFill "Guide Hollywood" @{b}NOM@{ub} FloodFill -- remplir la zone de la brosse avec une couleur (V2.0) @{b}SYNOPSIS@{ub} FloodFill(id, x, y, bordercolor, color) @{b}FONCTION@{ub} Cette commande peut être utilisé pour remplir la zone qui délimite la brosse spécifié par id avec une couleur. Vous devez indiquer une position de départ avec les arguments x et y. FloodFill() commencera alors à remplacer toutes les pixels se trouvant dans la zone entre le dessin de la brosse et les bords de celle-ci par la couleur spécifié par color. La position de démarrage est habituellement une position aléatoire dans la zone non dessiné. @{b}INPUTS@{ub} id - brosse à utiliser pour le remplissage x - commencer à la position x pour la commande de remplissage y - commencer à la position y pour la commande de remplissage bordercolor - couleur du bord color - couleur à utiliser pour remplir @{b}EXEMPLE@{ub} CreateBrush(1, 241, 201) SelectBrush(1) SetFillStyle(#FILLNONE) Ellipse(0, 0, 120, 100, #RED) EndSelect FloodFill(1, 120, 100, #RED, #WHITE) DisplayBrush(1, 0, 0) Créer un contour rouge en forme d'ellipse et remplit la zone avec la couleur blanche en utilisant la commande FloodFill() à partir du centre de l'ellipse. @ENDNODE @NODE SelectAlphaChannel "Guide Hollywood" @{b}NOM@{ub} SelectAlphaChannel -- sélectionner le canal alpha d'une brosse comme périphérique de sortie vidéo (V2.0) @{b}SYNOPSIS@{ub} SelectAlphaChannel(id) @{b}FONCTION@{ub} Cette commande sélectionne le canal alpha de la brosse spécifiée par id comme périphérique de sortie vidéo. Cela signifie que toutes les données d'affichage qui sont transmises par Hollywood seront tracé dans ce canal alpha. Le canal Alpha peut être utilisé pour donner à chaque Pixel son propre réglage de transparence. Il y a 256 niveaux différents de transparence disponible pour chaque Pixel. Une valeur de canal alpha de 0 signifie que le Pixel est entièrement transparent et une valeur de canal alpha de 255 signifie que le Pixel est opaque. Toutes les commandes Hollywood d'affichage ou de traçage seront générés avec un canal alpha dans le canal alpha de la brosse. Vous pouvez régler l'intensité en utilisant la commande @{"SetAlphaIntensity()" LINK SetAlphaIntensity}. Alternativement, vous pouvez régler le canal alpha avec l'argument #VANILLACOPY en utilisant la comande @{"SetAlphaIntensity()" LINK SetAlphaIntensity}. Ainsi , toutes les commandes Hollywood d'affichage ou de traçage qui généres des Pixel avec un canal alpha seront copié dans le canal alpha de la brosse. Le mode de copy Vanilla est une nouvelle caractéristique de Hollywood 2.5. L'argument color qui est utilisé dans plusieurs commandes de Hollywood (comme @{"Box()" LINK Box} ou @{"Circle()" LINK Circle}) , n'est pas nécessaire dans se cas. Vous devez utiliser @{"SetAlphaIntensity()" LINK SetAlphaIntensity} quand vous générez des canaux alphas. Les canaux alphas sont habituellement utilisés pour créer avec style, des images de fonds ou pour évité l'effet escalier de vos images. Si vous n'avez pas besoin de différent niveau de transparence mais seulement deux choix, à savoir Pixel transparents et Pixel opaques, vous devrez utiliser @{"SelectMask()" LINK SelectMask} car bien plus rapide à l'affichage. Noter que les brosses ne peuvent pas avoir un masque et un canal alpha. Un seul réglage de transparence est possible. Donc, si vous utilisez cette commande sur une brosse qui a un masque, ce masque sera effacé. Si la brosse que vous spécifiez dans id n'a pas de canal alpha, il sera automatiquement créé quand vous appelerez une commande qui veut générer un canal alpha. Le canal alpha créé sera alors opaque, c.-à-d. que chaque Pixel aura une intensité de canal alpha de 255, se qui signifie qu'elle n'est pas transparente. Pour annuler le mode de rendu avec le canal alpha et retourner à la l'affichage principal (sortie vidéo), exécuter la commande @{"EndSelect()" LINK EndSelect}. Si vous n'avez plus besoin du canal alpha, vous devez utiliser la commande @{"DeleteAlphaChannel()" LINK DeleteAlphaChannel} pour la retirer de la brosse. Vous ne pouvez pas utiliser les liens de brosse avec cette commande parce que les données graphiques de la brosse spécifié par id seront changés. Il est impossible d'utiliser les commandes qui redimensionne la brosse qui est actuellement utilisé comme périphérique de sortie vidéo, par exemple vous ne pouvez pas exécuter @{"ScaleBrush()" LINK ScaleBrush} pour redimensionner la brosse qui est actuellement utilisé comme périphérique de sortie vidéo. Seul les commandes qui affichent des graphismes statiques peuvent être utilisées quand SelectAlphaChannel() est activé. Vous ne pouvez pas exécuter les commandes d'animation comme @{"MoveBrush()" LINK MoveBrush} ou @{"DisplayBrushFX()" LINK DisplayBrushFX} quand SelectAlphaChannel() est activé. @{b}INPUTS@{ub} id - brosse dont le canal alpha sera utilisé comme périphérique de sortie vidéo @{b}EXEMPLE@{ub} CreateBrush(1, 256, 50, #RED) ; créer une brosse de dimension 256x50 SelectAlphaChannel(1) ; sélectionner son canal alpha comme périphérique de sortie vidéo For k = 255 To 0 Step -1 SetAlphaIntensity(k; régler le canal alpha avec l'intensité k Line(255 - k, 0, 255 - k, 49) ; tracer 256 lignes avec des intensités différente Next EndSelect ; sélectionner l'écran comme périphérique de sortie vidéo DisplayBrush(1, #CENTER, #CENTER) ; afficher la brosse Ce code afficher les 256 différents niveaux de transparence en créant une brosse avec la largeur de 256 Pixel et trace 256 lignes avec différent réglages de transparence. Le résultat sera un rectangle rouge qui doucement deviendra de plus en plus transparent avec l'image de fond. Noter que vous avez besoin d'un écran 24 bit. Sur des écrans 15 et 16 bits, il n'y aura pas assez de couleur pour afficher tous les différents niveaux. @ENDNODE @NODE DeleteAlphaChannel "Guide Hollywood" @{b}NOM@{ub} DeleteAlphaChannel -- retirer le canal alpha d'une brosse (V2.0) @{b}SYNOPSIS@{ub} DeleteAlphaChannel(id) @{b}FONCTION@{ub} Cette commande retire le canal alpha de la brosse spécifiée par id. Lire la documentation de @{"SelectAlphaChannel()" LINK SelectAlphaChannel} pour plus d'information. @{b}INPUTS@{ub} id - brosse dont le canal alpha doit être effacé @ENDNODE @NODE SetAlphaIntensity "Guide Hollywood" @{b}NOM@{ub} SetAlphaIntensity -- définir l'intensité du canal alpha généré (V2.0) @{b}SYNOPSIS@{ub} SetAlphaIntensity(level) @{b}FONCTION@{ub} Cette commande vous permet de spécifier le niveau de transparence pour toutes les commandes graphiques qui génére dans le canal alpha d'une brosse (quand @{"SelectAlphaChannel()" LINK SelectAlphaChannel} est activé). Le niveau de transparence doit être dans la gamme de 0 à 255, où 0 signifie la transparence 100% et 255 aucune transparence. L'intensité que vous spécifiez ici sera utilisé par toutes les commandes graphique de Hollywood au lieu d'une couleur. Le niveau peut également être une chaîne contenant une spécification en pourcentage, par exemple "50%". Noter que c'est juste le contraire de @{"SetLayerTransparency()" LINK SetLayerTransparency}. 255 définie aucune transparence et 0 une transparence compléte. Lire la documentation de @{"SelectAlphaChannel()" LINK SelectAlphaChannel} pour plus d'information. Nouveau dans V2.5 : Vous pouvez également indiquer l'argument #VANILLACOPY. Si vous indiquez ceci, Hollywood activera le nouveau mode de copie Vanilla. Ceci signifie que toutes les commandes graphiques qui générent des Pixel de canal alpha seront copiés directement dans le canal alpha de votre brosse. Par exemple, si vous sélectionnez le canal alpha d'une brosse et que vous utilisez @{"TextOut()" LINK TextOut} pour afficher du texte, Hollywood généra les données graphiques exactes de canal alpha du texte dans le canal alpha de votre brosse. @{b}INPUTS@{ub} level - niveau désiré de transparence (0 à 255 ou une spécification en pourcentage) ou : la constante spéciale #VANILLACOPY pour le mode de copie Vanilla (V2.5) @{b}EXEMPLE@{ub} voir @ {TIGE SelectAlphaChannel de " SelectAlphaChannel () "} @ENDNODE @NODE MixRGB "Guide Hollywood" @{b}NOM@{ub} MixRGB -- Mélanger 2 couleurs(V2.0) @{b}SYNOPSIS@{ub} color = MixRGB(col1, col2, ratio) @{b}FONCTION@{ub} Cette commande mélange les deux couleurs spécifié à un taux spécifié qui doit être dans la gamme de 0 à 255. La deuxième couleur sera mélangée à la première couleur selon le taux spécifié, c.-à-d. que si le taux est à 0, la couleur col1 sera retourné et si le taux est à 255, la couleur col2 sera retourné. Le taux peut également être une chaîne de caractères contenant une valeur en pourcentage. Par exemple "50%". @{b}INPUTS@{ub} col1 - couleur 1 au @{"format RGB" LINK RGBInfo} col2 - couleur 2 au @{"format RGB" LINK RGBInfo} ratio - taux de mélange (0 à 255 ou valeur en porcentage) @{b}RESULTAT@{ub} color - couleur mélangée @{b}EXEMPLE@{ub} c = MixRGB(#RED, #BLUE, 128) Ceci donnera une couleur rosé. @ENDNODE @NODE CropBrush "Guide Hollywood" @{b}NOM@{ub} CropBrush -- couper une brosse (V2.0) @{b}SYNOPSIS@{ub} CropBrush(id, x, y, width, height) @{b}FONCTION@{ub} cette commande coupe la brosse spécifié par id à la position spécifié par x et y à la dimension spécifié par width et height. Si la brosse a un masque et/ou un canal alpha, ils seront aussi coupés. @{b}INPUTS@{ub} id - brosse à couper x - position x de découpage y - position y de découpage width - largeur de découpe height - hauteur de découpe @{b}EXEMPLE@{ub} CreateBrush(1, 200, 200) SelectBrush(1) Circle(50, 50, 50, #RED) EndSelect CropBrush(1, 50, 50, 101, 101) DisplayBrush(1, #CENTER, #CENTER) Créé une nouvelle brosse et trace un cercle rouge en son centre. Ensuite, l'endroit vide entourant le cercle sera coupé. @ENDNODE @NODE Arc "Guide Hollywood" @{b}NOM@{ub} Arc -- tracer une partie d'ellipse (V2.0) @{b}SYNOPSIS@{ub} Arc(x, y, xradius, yradius, start, end[, color, clockwise, rotate]) @{b}FONCTION@{ub} Cette commande trace une partie d'ellipse (un arc) à la position spécifié par x:y avec les rayons et la couleur spécifiés (valeur RGB) dans le style configuré avec les commandes @{"SetFormStyle()" LINK SetFormStyle} et @{"SetFillStyle()" LINK SetFillStyle}. Les arguments start et end spécifient les angles de début et de fin de l'ellipse et doivent être spécifié en degrés. Si vous voulez tracer une ellipse fermée, l'argument start doit être 0 et l'argument end doit être 360. @{"Ellipse()" LINK Ellipse} est bien plus facile dans ce cas. Dans Hollywood 2.5 la commande arc() a été amélioré: Vous pouvez utiliser l'argument optionnel clockwise pour spécifier si oui ou non l'arc elliptique sera tracé dans le sens des aiguilles d'une montre. Cet argument est réglé par défaut sur TRUE, se qui signifie tracer dans le sens des aiguilles d'une montre. Si vous le réglez à FALSE, Arc() modifiera les angles dans le sens inverse des aiguilles d'une montre. De plus, l'argument optionnel rotate a été ajouté dans Hollywood 2.5. Avec cet argument vous pouvez tracer des arcs elliptiques pivotés. Spécifier simplement un angle entre 0 et 360 degrés et Arc() tracera une ellipse partielle pivotée. Cet argument est par défaut à 0, se qui signifie aucune rotation. La largeur de l'ellipse partielle sera xradius * 2 + 1 (le point central) et la hauteur sera yradius * 2 + 1 (point central). Nouveau dans Hollywood 2.0 : La couleur peut également être une @{"valeur ARGB" LINK ARGBInfo} pour le traçage de l'alpha-blended. @{b}INPUTS@{ub} x - décalage en x pour l'ellipse y - décalage en y pour l'ellipse xradius - rayon x de votre ellipse yradius - rayon y de votre ellipse start - angle de démarrage en degrés (doit être positif) end - angle de fin en degrés (doit être positif) color - optionnel: couleur @{"RGB" LINK RGBInfo} ou @{"ARGB" LINK ARGBInfo} (défaut à #BLACK) la couleur est optionnelle puisqu'elle n'est pas requise quand vous générer un masque ou un canal alpha clockwise - optionnel: TRUE si Arc() doit connecter les angles dans dans le sens horaire, sinon FALSE (défaut à TRUE) (V2.5) rotate - optionnel: angle de rotation en degrés (V2.5) @{b}EXEMPLE@{ub} Arc(0, 0, 183, 183, 45, 315, #WHITE) Circle(164, 33, 16, #WHITE) Trace une forme de pac-man. @ENDNODE @NODE SetClipRegion "Guide Hollywood" @{b}NOM@{ub} SetClipRegion -- activer une région (V2.0) @{b}SYNOPSIS@{ub} SetClipRegion(id) @{b}FONCTION@{ub} Cette commande installe une région de clip qui à été précédemment créé en utilisant @{"CreateClipRegion()" LINK CreateClipRegion}. La région de clip sera activée jusqu'à ce que vous exécutiez SetClipRegion() avec la valeur spéciale #NONE - ceci retirera alors la région de clip. Hollywood détruira automatiquement la région de clip si vous affichez une nouvelle image de fond. Si une région de clip est installée, cela affectera également les constantes de coordonnées spéciale Hollywood, par exemple #RIGHT signifie le côté droit de la région de clip. Les réglages de marge seront également adaptés. Vous pouvez également installer une région de clip tandis que @{"SelectBrush()" LINK SelectBrush} est activé. Cette région de clip sera alors désactivée quand @{"EndSelect()" LINK EndSelect} sera exécuté. Si vous avez une région de clip installé sur votre écran principal et que vous exécutez une des commandes de génération hors-écran (par exemple @{"SelectBrush()" LINK SelectBrush}), la région de clip sera temporairement désactivée mais restorée quand vous exécuterez @{"EndSelect()" LINK EndSelect}. Exceptions. Vous ne pouvez pas utiliser SetClipRegion() si: - les calques sont activés. Le découpage de calque n'est pas supporté. - le périphérique de sortie vidéo actuel est un canal alpha - le périphérique de sortie vidéo actuel est un masque, c.-à-d. @{"SelectMask()" LINK SelectMask} activé Voir également la documentation de @{"CreateClipRegion()" LINK CreateClipRegion}. @{b}INPUTS@{ub} id - identificateur de la région clip à installer; utiliser @{"CreateClipRegion()" LINK CreateClipRegion} pour créer des régions de clip @{b}EXEMPLE@{ub} CreateClipRegion(1, #BOX, #CENTER, #CENTER, 320, 240) SetClipRegion(1) Circle(0, 0, 100, #RED) Circle(439, 0, 100, #RED) Circle(439, 279, 100, #RED) Circle(0, 279, 100, #RED) Instal une région clip de la taille 320x240 au centre d'un écran 640x480 et trace un cercle à chaque coins. Cependant, seulement une partie des cercles seront visible en raison de la région clip. @ENDNODE @NODE CreateClipRegion "Guide Hollywood" Artblink @{b}NOM@{ub} CreateClipRegion -- créer une région de clip (V2.0) @{b}SYNOPSIS@{ub} [id] = CreateClipRegion(id, type, ...) [id] = CreateClipRegion(id, #BOX, x, y, width, height) [id] = CreateClipRegion(id, #SHAPE, id, x, y) @{b}FONCTION@{ub} cette commande peut être utilisé pour créer une région de clip que toute les commandes graphiques d'Hollywood respecteront. CreateClipRegion() créer une nouvelle région de clip et lui affecte l'identificateur id. Si vous indiquez @{"Nil" LINK V6PrgTypeNil} comme id, CreateClipRegion() choisira automatiquement une identification vide et la renverra. Noter que CreateClipRegion() n'active pas la région de clip; ceci doit être effectuer en utilisant @{"SetClipRegion()" LINK SetClipRegion}. Les régions de clip sont utiles pour limiter la zone de votre écran, où des images peuvent être affichés, par exemple si vous avez un écran de jeu avec deux parties: La zone de niveau et la bar de status (vies, munitions etc.). il peut être utile d'installer une région de clip qui définira les limites de la zone de niveau de sorte que les sprites ne soient jamais affiché à l'extérieur de cet zone. Toutes les commandes graphiques de Hollywood respecteront la région de clip que vous installerez en utilisant cette commande. Aucune image ne sera affiché en dehors des limites de votre région de clip. Il y a deux différents types de région de clip : Rectangulaire (#BOX) et customisé (#SHAPE). Tracer des régions clip rectangulaires est généralement plus facile et rapide. Si vous voulez installer une région de clip rectangulaire, vous devez spécifier sa position en x et y ainsi que ses dimensions width et height. Une région de clip customisé peut être installé en spécifiant une brosse, dont le masque doit être utilisé comme région de clip. En outre, vous devez spécifier le décalage x et y pour définir la position de la région clip sur l'écran, par exemple. Si vous avez un masque de dimension 320x240 mais un écran de dimension 640x480, vous pourrez centrer la région de clip sur l'écran. Si vous installez une région de clip customisé en utilisant le masque d'une brosse, Hollywood sera en mesure de tracer tous les pixel visibles du masque, donc tous les pixel invisibles du masque seront coupé. Voir la documentation de @{"SetClipRegion()" LINK SetClipRegion} pour plus d'information Pour libérer une région de clip créée avec CreateClipRegion(), utiliser la commande @{"FreeClipRegion()" LINK FreeClipRegion}. @{b}INPUTS@{ub} id - identificateur pour la région de clip ou @{"Nil" LINK V6PrgTypeNil} pour @{"la sélection automatique d'id" LINK AutoIDSelect} type - type de région de clip à installer; #BOX, #SHAPE ou #NONE ... - les arguments suivants dépendent du type ; voir ci-dessus @{b}RESULTAT@{ub} id - optionnel: identificateur de la région de clip ; sera seulement retourné si vous indiquez @{"Nil" LINK V6PrgTypeNil} comme argument 1 (voir ci-dessus) @{b}EXEMPLE@{ub} voir @{"SetClipRegion()" LINK SetClipRegion} @ENDNODE @NODE FreeClipRegion "Guide Hollywood" @{b}NOM@{ub} FreeClipRegion -- libérer une région de clip (V2.0) @{b}SYNOPSIS@{ub} FreeClipRegion(id) @{b}FONCTION@{ub} cette commande libère une région de clip créée avec CreateClipRegion(). Si il y a des sprites qui sont attachés à cette région de clip, ils seront libérés parce que la région de clip n'existe plus. Voir également la documentation de @{"CreateClipRegion()" LINK CreateClipRegion} pour plus d'information. @{b}INPUTS@{ub} id - identificateur de la région de clip à libérer @{b}EXEMPLE@{ub} voir @{"SetClipRegion()" LINK SetClipRegion} @ENDNODE @NODE SetTitle "Guide Hollywood" @{b}NOM@{ub} SetTitle -- changer le titre de la fenêtre Hollywood @{b}SYNOPSIS@{ub} SetTitle(title$) @{b}FONCTION@{ub} Cette commande modifie le titre de la fenêtre Hollywood par celui spécifié dans title$. C'est seulement utile pour changer le titre pendant l'exécution d'Hollywood. Si vous voulez donner à votre application un titre global, utiliser juste la commande préprocesseur @{"@DISPLAY" LINK atDISPLAY}. @{b}INPUTS@{ub} title$ - nouveau titre de la fenêtre @{b}EXEMPLE@{ub} SetTitle("Mon super programme") Le code ci-dessus modifiera le titre de la fenêtre par "Mon super programme" @ENDNODE @NODE DeleteMask "Guide Hollywood" @{b}NOM@{ub} DeleteMask -- retirer le masque d'une brosse (V2.0) @{b}SYNOPSIS@{ub} DeleteMask(id) @{b}FONCTION@{ub} cette commande efface le masque de la brosse spécifié par id, c.-à-d. que la brosse sera opaque. @{b}INPUTS@{ub} id - brosse dont le masque doit être effacé @ENDNODE @NODE ConvertToBrush "Guide Hollywood" @{b}NOM@{ub} ConvertToBrush -- convertir un objet en brosse (V2.5) @{b}SYNOPSIS@{ub} ConvertToBrush(sourcetype, sourceid, id[, par]) @{b}FONCTION@{ub} Cette commande vous permet de convertir un objet graphique en une nouvelle brosse. C'est utile, par exemple, pour copier les caractéristiques d'une image d'une animation ou d'un sprite dans une brosse. Vous pourrez les modifier et les convertires en une animation ou un sprite. Vous pouvez également accéder aux graphismes de calques avec cette commande. Sourcetype spécifie le type de l'objet source qui sera converti en brosse. Avoir des graphismes en tant que brosses est plus aidant, parce que les brosses sont pour la plupart des graphismes simples à utilisés avec Hollywood. La majeure partie des commandes graphiques fonctionnent seulement avec les brosses. C'est pourquoi vous devriez convertir vos graphismes en format de brosse pour plus d'aisance. Sourcetype peut être l'un des types suivants: #ANIM - convertir une image d'une animation en brosse; ce type exige l'argument optionnel par qui spécifie l'image que vous voulez convertir ; si vous n'indiquez pas l'argument optionnel, la première image sera utilisée; les images d'une animation sont comptés à partir de 1 #BGPIC - convertir une image de fond en brosse #BRUSH - convertir une brosse dans une autre brosse; fait la même chose que la commande @{"CopyBrush()" LINK CopyBrush} #LAYER - convertir un calque en brosse (exige que la calques soient activés) #SPRITE - convertir un sprite en brosse; ce type exige l'argument optionnel par ce qui spécifie l'image que vous voulez convertir si vous n'indiquez pas l'argument optionnel, la première image sera utilisée; les images sont comptés à partir de 1 #TEXTOBJECT - convertir un objet texte en brosse @{b}INPUTS@{ub} sourcetype - type de l'objet source (voir la liste ci-dessus) sourceid - identification de l'objet source id - identification de la brosse à créer par - optionnel: seulement requis pour le type #ANIM ou #SPRITE (défauts à 1, se qui signifie convertir la première image) @{b}EXEMPLE@{ub} ConvertToBrush(#SPRITE, 1, 10, 5) Le code ci-dessus créé une nouvelle brosse avec l'identification 10. Cette brosse est la copie de l'image 5 du sprite numéro 1 (un sprite peut être plusieurs images successive qui définie une animation). @ENDNODE @NODE SpritesIntroduction "Guide Hollywood" @{b}Introduction aux sprites@{ub} Les Sprites sont les parties élémentaires de beaucoup d'applications. Ils peuvent être utilisés pour différents buts et Hollywood est très flexible avec les sprites parce qu'ils sont insérés dans le logiciel. Il n'y a aucune restriction sur la taille des sprites, leurs couleurs, leurs transparence, etc. Traditionnellement, les sprites sont utilisés pour les graphismes du joueur et des ennemis dans les jeux mais ils sont également maniable dans beaucoup d'autres cas. Les sprites ont trois attributs distinctifs qui les distingue des brosses: 1) Les Sprites sont toujours affiché en priorité (au dessus de tous les graphismes). 2) Chaque sprite peut être affiché seulement une fois sur l'écran. 3) Un Sprite peut avoir plusieurs image définissant une animation. *** 1) Les Sprites sont toujours affiché en priorité (au dessus de tous les graphismes). Essayer le code suivant : LoadBrush (1, " test.iff ") LoadSprite (1, " test2.iff ") DisplaySprite (1, 0, 0) DisplayBrush (1, 0, 0) Vous voyez que nous chargeons deux images : Brosse 1 et sprite 1. Maintenant nous affichons le sprite 1 et ensuite nous affichons la brosse 1. Normalement, la brosse 1 devrait être dessiné au-dessus du sprite 1 puisque @{"DisplayBrush()" LINK DisplayBrush} s'exécute après @{"DisplaySprite()" LINK DisplaySprite}. Cependant, les sprites sont toujours affiché en priorité et c'est pourquoi dans ce cas ci, la brosse 1 est dessinée derrière le sprite 1. Ceci s'applique à tous les commandes normales graphiques de Hollywood: Vous ne pouvez jamais afficher un graphismes de tout type au-dessus d'un sprite. Les Sprites sont toujours affiché en priorité et les commandes normales c.-à-d. les commandes qui n'interfère pas avec les sprites, ne peuvent ne jamais afficher de graphismes au dessus d'un sprite. Vous pouvez seulement afficher des sprites au dessus d'autres sprites. 2) Chaque sprite peut être affiché seulement une fois sur l'écran. Essayer le code suivant : LoadSprite(1, "test.iff") DisplaySprite(1, 0, 0) DisplaySprite(1, 100, 100) Vous voyez que nous affichons le sprite 1 deux fois. D'abord, il est affiché à 0:0 et affiché à 100:100. Puisque chaque sprite peut seulement être affiché une seule fois sur l'écran, le deuxième appel avec @{"DisplaySprite()" LINK DisplaySprite} n'affichera pas le sprite 1 mais le déplacera de 0:0 à 100:100. @{"DisplaySprite()" LINK DisplaySprite} vérifie si le sprite 1 est sur l'écran, et si il y est, il est selectionné et déplacé à la nouvelle position. Ainsi, vous pouvez facilement déplacer vos sprites sur l'écran. 3) Un Sprite peut avoir plusieurs image. Puisque les sprites sont souvent utilisés pour l'animation, chaque sprite peut contenir plusieurs images comme objet d'animation Hollywood. La commande @{"DisplaySprite()" LINK DisplaySprite} a un argument facultatif qui vous permet de spécifier quelle image il affichera. *** Informations supplémentaires sur l'implantation de sprite avec Hollywood: - Les Sprites sont liés aux régions Clip: Quand vous affichez un sprite pour la première fois, il sera lié à la région clip actuellement active. le sprite restera dans cette région Clip même si vous désactivez la région Clip plus tard. Pour insérer un sprite hors d'une région Clip, vous pouvez libérer la région Clip en utilisant @{"FreeClipRegion()" LINK FreeClipRegion} ou enlever le sprite en utilisant @{"RemoveSprite()" LINK RemoveSprite} et il l'affichera de nouveau quand aucune région Clip ne sera activé. - Si vous affichez une nouvelle image de fond, tous les sprites sur l'ancien fond d'écran seront automatiquement enlevées. - Les Sprites peuvent seulement être affichés sur votre écran. Vous ne pouvez pas afficher les sprites dans des brosses, masques ou canal alpha. - Les calques ne peuvent pas être utilisées avec des sprites. Ces deux concepts ne sont pas compatible. - La commande doublebuffer ne peut pas être utilisée avec des sprites. Si vous utilisez un doublebuffer, vous n'aurez pas besoin de sprites. @ENDNODE @NODE CopySprite "Guide Hollywood" @{b}NOM@{ub} CopySprite -- copier un sprite (V2.0) @{b}SYNOPSIS@{ub} CopySprite(source, dest) @{b}FONCTION@{ub} Cette commande copie le sprite spécifié par source et crée une copie du sprite dans DEST. Le nouveau sprite est indépendant de l'ancien sprite ainsi vous pouvez libérer le sprite source après qu'il ait été copié. Si vous voulez juste avoir un nouveau sprite avec les mêmes graphismes que votre ancien sprite, vous devez utiliser @{"CreateSprite()" LINK CreateSprite}. Il peut créer des liens de sprite qui prennent moins de ressources mémoires. @{b}INPUTS@{ub} source - identification du sprite source DEST - identification du sprite destination @ENDNODE @NODE CreateSprite "Guide Hollywood" @{b}NOM@{ub} CreateSprite -- créer un sprite (V2.0) @{b}SYNOPSIS@{ub} CreateSprite(id, type, ...) CreateSprite(id, #ANIM, source_id) CreateSprite(id, #BRUSH, source_id[, width, height, frames, fr_per_row, sourcex, sourcey]) CreateSprite(id, #SPRITE, source_id) CreateSprite(id, #TEXTOBJECT, source_id) @{b}FONCTION@{ub} Cette commande crée un nouveau sprite depuis la source spécifié. Le sprite source peut être une animation, une brosse, un sprite ou un objet textes. les arguments de CreateSprite() dépendent du type de la source que vous spécifiez. Si le type est #ANIM, indiquer simplement l'id de l'objet d'animation à utiliser dans l'argument 3. Si le type est #BRUSH, vous devez spécifier l'id de la brosse source dans l'argument 3. Vous pouvez également demander à CreateSprite() d'extraire plusieurs images d'une brosse. Si vous voulez effectuer ceci, vous devez au moins indiquer les arguments 'width', 'height' et 'frames'. 'width' et 'height' définissent les dimensions du sprite à créer et 'frames' spécifie combien d'images CreateSprite() doit lire depuis la brosse source. Si les images sont alignées dans plusieurs rangées dans la brosse source, vous devez également indiquer l'argument 'fr_per_row' pour indiquer à CreateSprite() combien d'images composent chaques rangée. Vous pouvez demander à CreateSprite() où il doit commencer à scanner dans la brosse en spécifiant les arguments 'sourcex' et 'sourcey' (défaut à 0). CreateSprite() commence alors à la position 'sourcex':'sourcey' et scan un nombre de 'frame' images avec les dimensions 'width' par 'height' depuis la brosse spécifié par 'source_id'. Après qu'il ait lu les images 'fr_per_row' il avance à la prochaine rangée. Si vous spécifiez seulement trois arguments CreateSprite() convertira simplement la brosse spécifié dans 'source_id' en sprite. Si le type est #SPRITE, CreateSprite() copiera le sprite spécifié dans source_id. La différence avec @{"CopySprite()" LINK CopySprite} est que CreateSprite() crée un lien de sprite se qui signifie que le nouveau sprite dépend de l'ancien sprite. Si l'ancien sprite est libéré, le nouveau sprite sera libéré automatiquement. Les liens de Sprite ont l'avantage qu'ils ne consomment pas autant de mémoire comme une copie créée avec @{"CopySprite()" LINK CopySprite}. Les liens de sprite sont préféré dans la plupart des cas. Si le type est #TEXTOBJECT, CreateSprite() créera un sprite depuis l'objet texte spécifié. Vous devez seulement indiquer l'id de l'objet texte source. @{b}INPUTS@{ub} id - identificateur pour le nouveau sprite type - type d'objet source ... - d'autres arguments qui dépendent du type spécifié (voir ci-dessus) @ENDNODE @NODE DisplaySprite "Guide Hollywood" @{b}NOM@{ub} DisplaySprite -- afficher un sprite (V2.0) @{b}SYNOPSIS@{ub} DisplaySprite(id, x, y[, frame]) @{b}FONCTION@{ub} Cette commande affiche le sprite spécifié dans l'id à la position spécifié. Si le sprite est déjà sur l'écran, il sera déplacé à la nouvelle position. L'argument facultatif peut être utilisé pour spécifier quel image sera affichée. Si elle est omise, DisplaySprite() afficherà la prochaine image du sprite (si le sprite a plusieurs images). @{b}INPUTS@{ub} id - identificateur du sprite à afficher x - position x désirée y - position y désirée frame - optionnel: image à afficher (défauts à 0 se qui signifie l'affichage de la prochaine image du sprite) @ENDNODE @NODE FlipSprite "Guide Hollywood" @{b}NOM@{ub} FlipSprite -- renverser un sprite (V2.0) @{b}SYNOPSIS@{ub} FlipSprite(id, xflip) @{b}FONCTION@{ub} Cette commande renverse (miroirs) le sprite spécifié par id si vous indiquez TRUE à xflip, le sprite sera renversé selon l'axe x sinon il sera renversé selon l'axe y. @{b}INPUTS@{ub} id - sprite à renverser xflip - TRUE pour horizontale (x), FALSE pour verticale (y) @ENDNODE @NODE FreeSprite "Guide Hollywood" @{b}NOM@{ub} FreeSprite -- libérer un sprite (V2.0) @{b}SYNOPSIS@{ub} FreeSprite(id) @{b}FONCTION@{ub} Cette commande libère la mémoire occupée par le sprite numéro id. Pour réduire la consommation de mémoire, vous devez libérer les sprites quand vous n'en avez plus besoin. Si le sprite est toujours sur l'écran et vous que vous exécutez FreeSprite() il sera enlevé avant d'être libéré. @{b}INPUTS@{ub} id - identificateur du sprite à libérer @ENDNODE @NODE LoadSprite "Guide Hollywood" @{b}NOM@{ub} LoadSprite -- charger un sprite (V2.0) @{b}SYNOPSIS@{ub} [id] = LoadSprite(id, filename$[, args]) @{b}FONCTION@{ub} Cette commande charge le sprite spécifié par filename$ dans la mémoire et lui assigne l'identification id. Si vous indiquez @{"Nil" LINK V6PrgTypeNil} comme id, LoadSprite() choisira automatiquement une identification vide et la renverra. Les formats d'image compatibles sont png, JPEG, BMP, IFF ILBM, et bien plus selon la plate-forme où fonctionne Hollywood. L'argument facultatif 'args' accepte un tableau qui peut contenir d'autres options pour l'opération de chargement. Les champs suivants peuvent être placés dans le tableau args: Transparency: Spécifier ici une couleur qui sera transparente dans le sprite. La couleur que vous spécifiez ici sera masquée. LoadAlpha : Indiquer TRUE ici si l'image contient un canal alpha qui doit être chargé. X, Y, Width Height Frames, FPR : Tous ces items peuvent être utilisé pour affiner l'opération de chargement. Vous pouvez utiliser ces items pour que LoadSprite() crée un sprite avec plusieurs images depuis une image simple . 'Width' et 'Height' définissent les dimensions du sprite et 'Frames' spécifie combien d'images LoadSprite() doit lire depuis l'image source. Si les images sont alignées dans plusieurs rangées dans l'image source, vous devrez également indiquer l'argument 'FPR' (Frame per Row: Nbre d'images par rangée) pour indiquer à LoadSprite() combien d'images sont disposées dans chaque rangée. Vous pouvez indiquer à LoadSprite() la où dans l'image il doit commencer à scanner en spécifiant les items 'X' et 'Y' (défaut à 0). LoadSprite() commencera alors à la position 'X':'Y' et scannera 'Frames' images avec les dimensions 'Width' par 'Height' depuis l'image spécifié par filename$. Après qu'il ait lu le nombre 'FPR' d'images, il avance à la prochaine rangée. Noter que les indicateurs "Transparency" et "LoadAlpha" sont mutuellement exclusif. Un sprite ne peut pas avoir un masque et un canal alpha. Cette commande est également disponible par le préprocesseur: Utiliser @{"@SPRITE" LINK atSPRITE} pour précharger des sprites. @{b}INPUTS@{ub} id - identificateur pour le sprite ou @{"Nil" LINK V6PrgTypeNil} pour @{"la sélection automatique d'id" LINK AutoIDSelect} filename$ - fichier à charger args - optionnel: tableau qui spécifie d'autres options d'opération de chargement @{b}RESULTAT@{ub} id - optionnel: identificateur du sprite; sera seulement retourné quand vous indiquez @{"Nil" LINK V6PrgTypeNil} comme argument 1 (voir ci-dessus) @{b}EXEMPLE@{ub} LoadSprite(1, "dh0:MySprite.iff", {Transparency = #RED}) Ceci charge "dh0 :MySprite.iff" comme sprite 1 avec la couleur rouge transparente. ---- LoadSprite(1, "dh0:PlayerSprites.iff", {Width = 32, Height = 32, Frames = 16, FPR = 8, Transparency = #BLACK}) Le code ci-dessus crée le sprite 1 à partir du fichier "dh0 :PlayerSprites.iff". Le Sprite 1 aura les dimensions 32x32 et contiendra 16 images différentes. Les images sont alignées avec 8 images par rangée dans image "dh0 :PlayerSprites.iff". LoadSprite() doit scanner deux rangées pour lire les 16 images. @ENDNODE @NODE MoveSprite "Guide Hollywood" @{b}NOM@{ub} MoveSprite -- déplacer un sprite de a à b (V2.0) @{b}SYNOPSIS@{ub} MoveSprite(id, xa, ya, xb, yb[, table]) @{b}FONCTION@{ub} Cette commande déplace le sprite spécifié par id de l'endroit spécifié par xa ya à l'endroit spécifié par xb, yb. D'autres options de configuration sont possibles en utilisant l'argument optionnel table. Vous pouvez spécifier la vitesse de mouvement, des effets spéciaux, et si le mouvement doit être asynchrone. Voir la documentation de la commande @{"MoveBrush()" LINK MoveBrush} pour plus d'information. Sans compter les éléments de table mentionnés dans la documentation de MoveBrush(), MoveSprite() accepte un élément de table additionnel appelé "AnimSpeed": la valeur d'AnimSpeed définit la vitesse d'animation donc plus le nombre est élevé plus la vitesse d'affichage de l'animation sera rapide. @{b}INPUTS@{ub} id - identificateur du sprite à utiliser xa - position de la source en x ya - position de la source en y xb - position de la destination en x yb - position de la destination en y table - optionnel: d'autres options de configuration @{b}EXEMPLE@{ub} MoveSprite(1, 100, 50, 0, 50, {Speed = 5, AnimSpeed = 4}) Déplace le sprite 1 de 100:50 à 0:50 avec la vitesse de déplacemement de 5 et une vitesse d'animation de 4. @ENDNODE @NODE RemoveSprite "Guide Hollywood" @{b}NOM@{ub} RemoveSprite -- enlever un sprite de l'écran (V2.0) @{b}SYNOPSIS@{ub} RemoveSprite(id) @{b}FONCTION@{ub} Cette commande enlève le sprite spécifié par id de l'écran. Noter que le sprite ne sera pas libéré, ainsi vous pouvez l'afficher de nouveau si vous le souhaitez. @{b}INPUTS@{ub} id - identificateur du sprite à enlever @ENDNODE @NODE RemoveSprites "Guide Hollywood" @{b}NOM@{ub} RemoveSprites -- enlever tous les sprites de l'écran (V2.0) @{b}SYNOPSIS@{ub} RemoveSprites([keep]) @{b}FONCTION@{ub} Cette commande enlèvera tous les sprites de l'écran. Si vous indiquez TRUE dans l'argument optionnel 'kepp', les sprites seront toujours enlevés mais en plus ils seront générés en tant que graphismes normaux à l'écran. Ceci signifie que vous pourrez maintenant afficher d'autres graphismes par dessus ces sprites (par exemple une brosse "GAME OVER"). Si vous indiquez False dans 'keep', vous aurez l'impression que rien ne se passe. Cette impression est, cependant, erronée. Les sprites sont en effet enlevé mais vous ne verrez pas de différence parce qu'ils seront immédiatement générés en tant que graphismes normaux à l'écran, de sorte que vous puissiez afficher d'autres objets graphiques par dessus. @{b}INPUTS@{ub} keep - optionnel: TRUE si les sprites doivent être gardés en tant que graphismes normaux (défaut à FALSE) @ENDNODE @NODE ScaleSprite "Guide Hollywood" @{b}NOM@{ub} ScaleSprite -- redimensionner un sprite (V2.0) @{b}SYNOPSIS@{ub} ScaleSprite(id, width, height) @{b}FONCTION@{ub} Cette commande redimensionne le sprite spécifié par id à la largeur et la hauteur spécifié par width et height. Note: Vous devez toujours effectuer des opérations de redimensionnement avec le sprite original. Par exemple, si vous redimensionnez le sprite 1 à 12x8 et que vous le redimensionnez de nouveau à 640x480, vous obtiendrez une image de mauvaise qualité. Par conséquent vous devez toujours garder la brosse originale et redimensionner seulement des copies d'elle même. Nouveau dans v2.0: Vous pouvez indiquer #KEEPASPRAT en tant que largeur et hauteur. Hollywood calculera la taille automatiquement en prenant compte du ratio d'aspect du sprite. Depuis Hollywood 2.0, la largeur et la hauteur peuvent également être une chaîne contenant des spécifications en pourcentage, par exemple "50%". @{b}INPUTS@{ub} id - identificateur du sprite à redimensionner width - nouvelle largeur désirée pour le sprite height - nouvelle hauteur désirée pour le sprite @ENDNODE @NODE BeginDoubleBuffer "Guide Hollywood" @{b}NOM@{ub} BeginDoubleBuffer -- activer le mode double buffer (V2.0) @{b}SYNOPSIS@{ub} BeginDoubleBuffer() @{b}FONCTION@{ub} Cette commande active le double buufer d'Hollywood. Les graphismes qui seront afficher aprés que cette commande soit exécutée ne seront pas affiché tant que la commande @{"Flip()" LINK Flip} soit exécutée. Le double buffer est utilisé pour éviter que les mises à jour d'écran soient visible par l'utilisateur. Comme le nom l'indique, vous avez deux mémoires d'écran dans le mode double buffer: Un bloc mémoire vidéo avant (visible pour l'utilisateur) et un bloc mémoire vidéo arriére (non visible par l'utilisateur). Vos mises à jour d'écran seront toujours tracées dans le bloc mémoire vidéo arriére (la mémoire) et quand vous tous les éléments sont tracé, vous exécutez la commande @{"Flip()" LINK Flip} pour commuter le bloc mémoire vidéo vers l'avant. Ensuite, vous pouvez tracer de nouveau éléments graphiques dans la prochaine mise à jour d'écran qui seront tracés dans le le bloc mémoire vidéo arriére et ainsi de suite. Cette technique permet d'éciter un clignotement désagréable pour l'utilisateur puisque @{"Flip()" LINK Flip} régénérera toujours l'affichage de totalité en une seule fois. Quand Hollywood est en mode double buffer et qu'une fenêtre est redimensionné vos graphismes seront automatiquement redimensionnés pour s'adapter aux nouvelles dimensions. C'est une utilisation spécial qui est seulement possible avec le mode double buffer. Le double buffer est trés utile si un grand nombre d'éléments graphiques doivent être tracés ou affichés dans une mise à jour d'écran. Si vous devez seulement déplacer une petite image vous devriez plutôt utiliser des sprites qui sont bien plus rapide. Se rappeler que le mode double buffer régénére toujours l'écran dans sa totalité. Ainsi, si vous avez une application qui fonctionne en 640x480 à 25fps, il ne sera pas évident qu'il fonctionne avec Hollywood puisqu'il doit tracer un écran de 640x480 25 fois par seconde. Quelques restrictions s'appliquent : - Vous ne pouvez pas utiliser le double buffer quand les calques sont activés - Vous ne pouvez pas utiliser les sprites avec le mode double buffer - Le BGPic qui est activé quand BeginDoubleBuffe() est exécuté ne doit pas être transparent @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} BeginDoubleBuffer() CreateBrush(1, 64, 64, #RED) For k = -64 To 640 Cls DisplayBrush(1, k, #CENTER) Flip Next EndDoubleBuffer() Le code ci-dessus déplace un rectangle rouge de la gauche hors écran à la droite hors écran sans clignotement. Ce n'est pas un exemple évident parce que nous déplaçons seulement une petite image. C'est beaucoup de ressources utilisées puisque nous régénérerons 640x480 pixel juste pour cette petite image, vous pouvez améliorer se code en utilisant les sprites. Se rappeler que le double buffer est seulement recommandé quand il y a plusieurs éléments graphiques à tracer ou afficher. @ENDNODE @NODE EndDoubleBuffer "Guide Hollywood" @{b}NOM@{ub} EndDoubleBuffer -- désactive le mode double buffer (V2.0) @{b}SYNOPSIS@{ub} EndDoubleBuffer() @{b}FONCTION@{ub} Cette commande désactive le mode double buffer. Voir la documentation de @{"BeginDoubleBuffer()" LINK BeginDoubleBuffer} pour plus d'information. @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} voir @{"BeginDoubleBuffer()" LINK BeginDoubleBuffer} @ENDNODE @NODE Flip "Guide Hollywood" @{b}NOM@{ub} Flip -- Commuter les écrans avant et arriére (V2.0) @{b}SYNOPSIS@{ub} Flip() @{b}FONCTION@{ub} Cette commande commute l'écran arriére vers l'avant et redéfini l'écran précédement avant comme bloc mémoire vidéo arriére de sorte que vous puissiez tracer ou afficher la prochaine mise à jour d'écran. Voir la documentation de @{"BeginDoubleBuffer()" LINK BeginDoubleBuffer} pour plus d'information. @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} Voir @{"BeginDoubleBuffer()" LINK BeginDoubleBuffer} @ENDNODE @NODE ARGB "Guide Hollywood" @{b}NOM@{ub} ARGB -- composer une couleur avec la transparence alpha (V2.0) @{b}SYNOPSIS@{ub} color = ARGB(alpha, rgb) @{b}FONCTION@{ub} Cette commande combine une valeur de transparence alpha avec une couleur dans le format @{"RGB" LINK RGBInfo}. Une couleur 32 bits @{"ARGB" LINK ARGBInfo} sous le format $aarrggbb sera retourné. C'est utile avec les commandes de la @{"bibliothéque de traçage" LINK V6LibGfxDraw} puisqu'il peut également tracer des éléments graphiques alpha-blended. @{b}INPUTS@{ub} alpha - transparence alpha désiré (0-255) rgb - @{"couleurs RGB" LINK RGBInfo} standard @{b}RESULTAT@{ub} color - @{"couleurs ARGB" LINK ARGBInfo} @{b}EXEMPLE@{ub} Box(#CENTER, #CENTER, 320, 240, ARGB(128, #WHITE)) Le code ci-dessus trace un rectangle blanc alpha-blended . Le taux de mélange est de 128 (50%). @ENDNODE @NODE SetFormStyle "Guide Hollywood" @{b}NOM@{ub} SetFormStyle -- définir le modèle de forme pour les primitives graphiques (V2.5) @{b}SYNOPSIS@{ub} SetFormStyle(style, ...) SetFormStyle(#SHADOW, color, distance, direction) SetFormStyle(#EDGE, color, size) @{b}FONCTION@{ub} Cette commande peut être utilisée pour configurer le modèle de schéma pour les commandes de la bibliothéque de primitives graphiques. Cette commande agit directement sur l'apparence des éléments tracer avec les commandes @{"Arc()" LINK Arc} @{"Box()" LINK Box}, @{"Circle()" LINK Circle}, @{"Ellipse()" LINK Ellipse}, @{"Line()" LINK Line}, et @{"Polygon()" LINK Polygon}. Le modèle doit être l'une des constantes prédéfinies suivantes: #NORMAL - initialisation du modèle de forme au modèle par défaut #ANTIALIAS - régle le modèle de forme sur anticrénelage (effets escalier); les primitives graphiques seront tracées avec l'anticrénelage. #SHADOW - régle le modèle de forme avec ombre; les formes primitives graphiques aurons une ombre avec ce modèle; le deuxiéme argument spécifie la couleur de l'ombre; cette couleur peut être au format @{"RGB" LINK RGBInfo} ou @{"ARGB" LINK ARGBInfo}; la transparence de l'ombre est exploitée le troisiéme argument spécifie la distance de l'ombre de la forme principale en Pixel; le quatriéme argument spécifie la direction de l'ombre; celle-ci doit être une des @{"constantes directionnelles" LINK V6PrgDirectionCst} #EDGE - régle le modèle de forme avec un contour personnalisé; un contour de la taille spécifié sera tracé autour de la forme avec ce modèle; le deuxiéme argument spécifie la couleur de se contour; cette couleur peut être au format @{"RGB" LINK RGBInfo} ou @{"ARGB" LINK ARGBInfo} la transparence de se contour est exploitée; le troisiéme argument spécifie l'épaisseur désirée du contour en Pixel. Noter que la commande @{"Line()" LINK Line} ne supporte pas les modèles de forme #SHADOW et #EDGE. Elle reconait seulement le modèle #ANTIALIAS. @{b}INPUTS@{ub} style - constante spéciale de modèle (voir la liste ci-dessus) ... - encore d'autres arguments facultatifs qui dépendent du modèle indiqué comme argument 1 (voir ci-dessus) @{b}EXEMPLE@{ub} SetFormStyle(#ANTIALIAS) Cette commande ci-dessus permet d'activer le modèle de forme anticrénelage. SetFormStyle(#SHADOW, ARGB(128, $939393), 16, #SHDWSOUTHEAST) Le code ci-dessus créé une ombre grise transparente qui sera positionnée à 16 Pixel au sud-est de la forme principale. @ENDNODE @NODE HideDisplay "Guide Hollywood" @{b}NOM@{ub} HideDisplay -- cacher l'écran (V3.0) @{b}SYNOPSIS@{ub} HideDisplay() @{b}FONCTION@{ub} Cette commande cache l'affichage. L'exécution du script continuera tandis que l'affichage est caché. Vous pouvez utiliser la commande @{"ShowDisplay()" LINK ShowDisplay} pour rendre visible l'écran caché. @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} HideDisplay() Wait(100) ShowDisplay() Ce code cache l'affichage, attend 2 secondes, et affiche de nouveau l'écran. @ENDNODE @NODE ShowDisplay "Guide Hollywood" @{b}NOM@{ub} ShowDisplay -- afficher un écran caché (V3.0) @{b}SYNOPSIS@{ub} ShowDisplay() @{b}FONCTION@{ub} Cette commande réactive et affiche de nouveau un écran caché. L'écran doit avoir été caché avant en utilisant la commande @{"HideDisplay()" LINK HideDisplay} ou par l'utilisateur en utilisant le bouton de réduction de fenêtre. @{b}INPUTS@{ub} aucun @{b}EXEMPLE@{ub} Voir @{"HideDisplay()" LINK HideDisplay} @ENDNODE @NODE RemoveLayerFX "Guide Hollywood" @{b}NOM@{ub} RemoveLayerFX -- enlever un calque avec un effet de transition (V3.0) @{b}SYNOPSIS@{ub} RemoveLayerFX(id[, table]) [V4.0] RemoveLayerFX(id[, type, speed, arg]) [ancienne syntaxe jusqu'à la version 3.1] @{b}FONCTION@{ub} Cette commande est une version améliorée de la commande @{"RemoveLayer()" LINK RemoveLayer}. Il enlève le calque spécifié par id et utilise un des nombreux effets de transitions d'Hollywood. Vous pouvez également spécifier la vitesse pour la transition et un argument optionnel. Depuis Hollywood 4.0 cette commande utilise une nouvelle syntaxe avec juste un simple tableau comme argument optionnel. L'ancienne syntaxe est encore supporté pour des raisons de compatibilité. Le tableau d'argument optionnel peut être utilisé pour configurer l'effet de transition. Les options suivantes sont possibles : Type : Spécifie l'effet désiré pour la transition. Pour une liste de tous les effets de transitions disponibles, lire la documentation de la commande @{"DisplayTransitionFX()" LINK DisplayTransitionFX}. (défauts: #RANDOMEFFECT) Speed : Spécifie la vitesse désirée pour la transition. Plus la valeur spécifié ici sera élevé, plus l'effet sera affiché rapidement. (défauts: #NORMALSPEED) Parameter: Quelques effets de transition acceptent un paramétre additionnel. Celui-ci peut être spécifié ici. (défauts: #RANDOMPARAMETER) Async : Vous pouvez utiliser cet indicateur pour créer un objet asynchrone pour cette transition. Si vous indiquez TRUE ici RemoveLayerFX() sera quitté immédiatement, redonnant la main pour un objet asynchrone que vous pouvez alors tracer en utilisant AsyncDrawFrame(). Lire la documentation de @{"AsyncDrawFrame()" LINK AsyncDrawFrame} pour plus d'information. Vous avez besoin @{"d'activer les calques" LINK EnableLayers} avant d'utiliser cette commande. Pour comprendre le fonctionnement des calques, lire @{"l'introduction aux calques" LINK LayersIntroduction}. @{b}INPUTS@{ub} id - identificateur ou nom du calque à cacher table - optionnel: tableau configurant la transition @{b}EXEMPLE@{ub} RemoveLayerFX(5, #CROSSFADE) ; ancienne syntaxe OU RemoveLayerFX(5, {Type = #CROSSFADE}) ; nouvelle syntaxe Le code ci-dessus enléve le calque 5 avec une transition crossfade. @ENDNODE @NODE GetAnimFrame "Guide Hollywood" @{b}NOM@{ub} GetAnimFrame -- copier l'image d'une animation dans une brosse (V3.0) @{b}SYNOPSIS@{ub} GetAnimFrame(id, frame, animid) @{b}FONCTION@{ub} Cette commande peut être utilisée pour convertir une image d'une animation en une brosse. L'animation doit avoir été chargée en utilisant @{"LoadAnim()" LINK LoadAnim} ou la commande préprocesseur @{"@ANIM" LINK atAnim}. Si vous voulez charger une image directement depuis un fichier d'animation, utiliser @{"LoadAnimFrame()" LINK LoadAnimFrame} à la place. GetAnimFrame() est à utilisé en priorité, parce qu'il est plus rapide. Dans le premier argument, indiquer une identification pour la brosse que vous voulez que cette commande crée. Dans le second argument vous devez spécifier quelle image de l'animation doit être chargé, et le troisiéme argument spécifie finalement l'identification de l'animation à utiliser comme source. @{b}INPUTS@{ub} id - identification de la brosse à créer par cette commande frame - image à charger (de 1 au nombre d'images);indiquer -1 si vous voulez charger la derniére image animid - identification de l'animation à utiliser comme source @{b}EXEMPLE@{ub} LoadAnim(1, "TestAnim.anim") GetAnimFrame(1, 15, 1) Le code ci-dessus convertis l'image 15 de l'animation 1 dans la brosse 1. @ENDNODE @NODE CopyBGPic "Guide Hollywood" @{b}NOM@{ub} CopyBGPic -- copier une image de fond (V4.0) @{b}SYNOPSIS@{ub} CopyBGPic(source, dest) @{b}FONCTION@{ub} Cette commande copie l'image de fond spécifié par source et crée une copie dans DEST. La nouvelle image de fond est indépendante de l'ancienne ainsi vous pouvez libérer l'image de fond source aprés qu'elle ait été copiée. Noter que seul les données graphiques de l'image de fond seront copiées. CopyBGPic() ne copiera aucun calque, sprites, ou boutons attachés à l'image de fond. @{b}INPUTS@{ub} source - identification de l'image de fond de source dest - identification de l'image de fond à créer @{b}EXEMPLE@{ub} CopyBGPic(1, 10) FreeBGPic(1) Le code ci-dessus crée une nouvelle image de fond 10 qui contient les mêmes données graphiques que l'image de fond 1. Puis elle libére l'image de fond 1 parce qu'elle n'est plus utilisé. @ENDNODE @NODE GetRandomFX "Guide Hollywood" @{b}NOM@{ub} GetRandomFX -- choisir un effet de transition de façon aléatoire (V4.0) @{b}SYNOPSIS@{ub} fx = GetRandomFX(objfx) @{b}FONCTION@{ub} Cette commande choisit simplement un effet de transition Hollywood aléatoirement parmis la palette des effets de transition. Vous devez spécifier dans l'argument 1 si oui ou non l'effet de transition s'appliquera à tous les objets ou seulement pour l'images de fond. GetRandomFX() scanera alors les effets disponibles et retournera un effet aléatoire que vous pouvez alors indiquer aux commandes d'effets graphiques comme @{"DisplayBrushFX()" LINK DisplayBrushFX} et @{"DisplayTransitionFX()" LINK DisplayTransitionFX}. Normalement, vous ne devez pas utiliser cette commande puisque vous pouvez simplement indiquer #RANDOMEFFECT avec toutes les fonctions d'effets spéciaux. GetRandomFX() est seulement utile si vous voulez filtrer des effets, c.-à-d. que vous voulez choisir un effet aléatoirement mais pas #WATER1, par exemple. Dans ce cas, vous pouvez appeler GetRandomFX() jusqu'à ce qu'il renvoie un effet qui est différent de celui que vous ne voulez pas. Voir la documentation de la commande @{"DisplayTransitionFX()" LINK DisplayTransitionFX} pour vous renseigner sur les différents types de transition de Hollywood. @{b}INPUTS@{ub} objfx - TRUE si vous voulez un effet sur un objet ou FALSE pour un effet sur une image de fond @{b}RESULTAT@{ub} fx - un effet de transition choisi aléatoirement @{b}EXEMPLE@{ub} Repeat fx = GetRandomFX(FALSE) Until fx <> #WATER1 DisplayTransitionFX(2, fx) Le code ci-dessus choisit un effet de façon aléatoire sur une image de fond mais jamais l'effet #WATER1. Ensuite aprés avoir choisi l'effet, l'image de fond 2 est affichée avec cet effet. @ENDNODE @NODE ScaleLayer "Guide Hollywood" @{b}NOM@{ub} ScaleLayer -- redimensionner un calque (V4.0) @{b}SYNOPSIS@{ub} ScaleLayer(id, width, height[, smooth]) @{b}FONCTION@{ub} Cette commande redimensionne le calque spécifé par id à la largeur et la hauteur spécifié par width et height. Un option vous permet d'obtenir des graphismes redimensionnés avec une interpolation en indiquant TRUE dans l'argument smooth. Les graphismes seront alors redimensionnés en utilisant l'antialiasing. Quand le calque spécifié est un calque vectoriel (par exemple cercle polygone, texte truetype ou un rectangle) Hollywood pourra redimensionner le calque sans perte de qualité puisque les graphismes vectoriels peuvent être librement transformé. Ainsi, l'argument "smooth" n'a aucune fonction si le calque spécifié est un calque vectoriel. Si le calque contient une image, le sous programme normales de redimensionnement sera utilisé. Contrairement au redimensionnement des brosses en utilisant @{"ScaleBrush()" LINK ScaleBrush} les calques gardent toujours leurs données originales donc vous n'aurez aucune perte de qualité si vous redimensionner un calque (20.15) et lui redonner sa taille original (640.480). La largeur et la hauteur peuvent également être une chaîne contenant des spécifications en pourcentage, exemple "50%". @{b}INPUTS@{ub} id - identification du calque à redimensionner width - nouvelle largeur désirée pour le calque height - nouvelle hauteur désirée pour le calque smooth - optionnel: si oui ou non le redimensionnement avec Antialiasing doit être utilisé (seulement applicable si le calque n'est pas un calque vectoriel) @{b}EXEMPLE@{ub} ScaleLayer(1,640,480) Redimensionne le calque 1 à une résolution de 640x480. @ENDNODE @NODE RotateLayer "Guide Hollywood" @{b}NOM@{ub} RotateLayer -- pivoter un calque (V4.0) @{b}SYNOPSIS@{ub} RotateLayer(id, angle[, smooth]) @{b}FONCTION@{ub} Cette commande pivote le calque spécifé par id de l'angle spécifié (en degrés). Un angle positif pivote le calque dans le sens contraire des aiguilles d'une montre, un angle négatif pivote le calque dans le sens des aiguilles d'une montre. En plus, vous pouvez pivoter le calque en utilisant l'interpolation en indiquant TRUE dans l'argument smooth. Les graphimes seront alors pivoté en utilisant l'antialiasing. Quand le calque spécifié est un calque vectoriel (par exemple cercle polygone, texte true type ou un rectangle) Hollywood pourra pivoter le calque sans perte de qualité puisque les graphismes vectoriels peuvent être librement transformé. Ainsi, l'argument "smooth" n'a aucune fonction si le calque spécifié est un calque vectoriel. Si le calque contient une image, le sous programme normales de rotation sera utilisé. Contrairement aux brosses pivotées en utilisant @{"RotateBrush()" LINK RotateBrush} les calques gardent toujours leurs données originales donc vous n'aurez aucune perte de qualité si vous pivotez un calque de quelques degrés et en arriére à son angle original. C'est possible et cela n'engendre aucune perte de qualité avec RotateLayer(). @{b}INPUTS@{ub} id - calque à pivoter angle - angle de rotation en degrés smooth - optionnel: si oui ou non la rotation avec Antialiasing doit être utilisé (seulement applicable si le calque n'est pas un calque vectoriel) @ENDNODE @NODE SetLayerStyle "Guide Hollywood" @{b}NOM@{ub} SetLayerStyle -- changer le modèle d'un ou plusieurs calques (V4.0) @{b}SYNOPSIS@{ub} SetLayerStyle(id1, style1, ...) @{b}FONCTION@{ub} Cette commande peut être utilisée pour modifier presque tous les attributs d'un ou plusieurs calques existants avec un simple appel. C'est une commande trés puissante qui peut être utilisé pour réaliser des mécanismes d'animation complexes facilement. Pour chaque modèle de calque que vous voulez modifier vous devez toujours indiquer son id de calque suivi d'un tableau contenant les attributs que vous voulez changer. Vous pouvez répéter ce modèle autant de fois que vous en avez besoin. La configuration du tableau de modèle dépend du type de calque spécifié. Cependant, quelques éléments de modèle peuvent être utilisés avec tous les types de calque. Ces modèles génériques de calque seront couverts en premier. Les modèles de calque spécifié dépendants du type de calque seront traités ci-dessous. Les éléments de modèle suivants sont génériques et peuvent être utilisés sur chaque calque: X, Y : spécifie la position du calque. Si il n'est pas spécifié le calque gardera sa position initiale. Width,Height : Peut être utilisé pour redimensionner le calque. Ceci peut être soit une valeur numérique spécifiant une nouvelle taille en Pixel soit une chaîne contenant des spécifications en pourcentage (par exemple "50%"). Pour plus d'information sur le redimensionnement de calque, voir la documentation sur @{"ScaleLayer()" LINK ScaleLayer}. Rotate : Cet élément de modèle peut être utilisé pour pivoter le calque. Vous devez indiquer ici une valeur en degrés. Une valeur positive signifie une rotation dans le sens contraire des aiguilles d'une montre, une valeur négative signifie une rotation dans le sens des aiguilles d'une montre. Pour plus d'information, voir @{"RotateLayer()" LINK RotateLayer}. SmoothScale : Spécifie si le redimensionnement et la rotation doit avoir un effet lisser sur ce calque. C'est seulement applicable pour les calques Bitmaps et non vectoriels. Transparency : utiliser cet élément de modèle pour modifier la configuration de transparence d'un calque. Cela peut être une valeur allant de 0 (= non transparent) à 255 (= complétement transparent) ou à une chaîne contenant des spécifications en pourcentage (par exemple "50%" qui signifie à moitié transparent). Pour plus d'information voir la documentation de @{"SetLayerTransparency()" LINK SetLayerTransparency}. Tint : utiliser cet élément de modèle pour modifier la configuration de teinte d'un calque. Cela peut être une valeur allant de 0 (= aucune teinture) à 255 (= teinture opaque) ou une chaîne contenant des spécifications en pourcentage (par exemple "50%" qui signifie la moitié teintée). Si ceci n'est pas indiqué, le calque sera teinté de la couleur spécifié dans "TintColor" au niveau spécifié. Pour plus d'information, voir la documentation de @{"SetLayerTint()" LINK SetLayerTint}. TintColor : Spécifie la couleur à utiliser pour la teinture. Peut seulement être utilisé en lien avec l'élément de modèle "Tint". Hidden : Vous pouvez utiliser cet élément de modèle pour afficher ou cacher le calque spécifié. Réglé le à TRUE pour cacher le calque ou à FALSE pour l'afficher. Pour plus d'information voir @{"HideLayer()" LINK HideLayer} et @{"ShowLayer() LINK ShowLayer}. * * * Les éléments de modèle suivants dépendent du type de calque spécifié : les calques #ANIM peuvent utiliser les éléments suivants : ID : Cet élément de table peut être utilisé pour assigner une nouvelle animation au calque spécifié. L'ancienne animation sera alors remplacé par l'animation spécifié par id. Frame : Vous pouvez utiliser cet élément de modèle pour afficher une image spécifié de l'animation qui se repose sur se calque. Vous pouvez indiquer 0 pour afficher la prochaine image de l'animation. Lire la documentation de @{"NextFrame()" LINK NextFrame} pour plus d'information. * * * les calques #BRUSH, #BRUSHPART et #BGPICPART identifient les éléments suivants: ID : Cet élément de tableau peut être utilisé pour assigner une nouvelle brosse/bgpic au calque spécifié. L'ancienne brosse/bgpic sera alors remplacé par la nouvelle spécifié par id. C'est utile par exemple pour une présentation dans laquelle un calque affichera une nouvelle image chaque secondes. PartX, PartY : ces quatres éléments vous permettent de configurer la partie PartWidth visible de la brosse ou bgpic. PartX et PartY spécifient les PartHeight coordonnées x et y à l'intérieur de la brosse/bgpic et PartWidth et PartHeight spécifie la taille de la partie qui sera visible. C'est utile pour afficher seulement une partie d'une brosse ou bgpic. Pour plus d'information lire la description de @{"DisplayBrushPart()" LINK DisplayBrushPart} et @{"DisplayBGPicPart()" LINK DisplayBGPicPart}. Noter que ces éléments ne sont pas limités pour ses types de calques #BRUSHPART et #BGPICPART peuvent également être utilisés avec des calques de type #BRUSH. Si vous utilisez un des éléments PartXXX sur le calque #BRUSH, le calque sera automatiquement modifié en calque #BRUSHPAT. * * * Les éléments suivants sont génériques pour les types de calques #ARC, #BOX #CIRCLE, #ELLIPSE et #POLYGON : Color : Spécifie la couleur du calque dans le format ARGB. FormStyle : Ceci vous permet de changer la forme du modèle de calque. Vous pouvez indiquer ici un ou plusieurs modèles. Si vous indiquez plusieurs formes de modèles, vous devez utiliser l'opérateur OR (|). Pour les combinaisons possibles, lire la documentation de la commande @{"SetFormStyle()" LINK SetFormStyle}. Si vous voulez enlever un modèle de forme d'un calque utiliser l'élément "FormStyleClear". FormStyleClear : Tous les modèles de forme que vous indiquez dans cet élément seront enlevé du calque. Les modèles de forme multiples doivent être séparé par l'opérateur OR (|). C'est le contraire de l'élément "FormStyle". ShadowDir : Spécifie la direction de l'ombre pour ce calque. Seulement utilisé si le modèle de forme est #SHADOW. ShadowColor : Spécifie la couleur de l'ombre pour ce calque. Seulement utilisé si le modèle de forme est #SHADOW. ShadowSize : Spécifie la taille de l'ombre pour ce calque. Seulement utilisé si le modèle de forme est #SHADOW. EdgeColor : Spécifie la couleur du contour pour ce calque. Seulement utilisé si le modèle de forme est #EDGE. EdgeSize : Spécifie la taille du contour pour ce calque. Seulement utilisé si le modèle de forme est #EDGE. FillStyle : Vous pouvez utiliser cet élément de modèle pour changer le modèle de remplissage pour ce calque. Lire la documentation de la commande @{"SetFillStyle()" LINK SetFillStyle} pour plus d'informations. GradientStyle : Spécifie le modèle de graduation si le modèle de remplissage est indiqué avec #FILLGRADIENT. Actuellement #LINEAR est le seul modèle de graduation supporté GradientAngle : Spécifie l'orientation de la graduation si le modèle de remplissage est indiqué avec #FILLGRADIENT. L'angle est exprimé en degrés. GradientStartColor : utiliser ces deux indicateurs pour configurer les GradientEndColor couleurs de la graduation si le modèle de remplissage est indiqué avec #FILLGRADIENT. OutlineThickness : Si le modèle de remplissage est indiqué avec #FILLNONE cette valeur peut être utilisé pour configurer l'épaisseur du contour. Voir SetFillStyle() pour plus d'information. TextureBrush : Si le modèle de remplissage est indiqué avec #FILLTEXTURE vous pouvez modifier la texture actuellement utilisée avec cet élément de modèle. Indiquer simplement l'id d'une brosse dans cet élément de modèle à commuter avec une nouvelle texture. * * * En plus des éléments ci-dessus, les calques de type #ARC acceptent les éléments de modèle suivant: RadiusA : ces deux valeurs spécifient les rayons de x et de y de l'ellipse RadiusB partielle StartAngle : ces deux valeurs spécifient les angles de début et de fin d'une EndAngle ellipse partielle. Lire la documentation de @{"Arc()" LINK Arc} pour plus d'information. * * * Les calques de type #BOX acceptent les éléments de modèle additionnels suivants: SizeX, SizeY : Vous pouvez utiliser ces deux valeurs pour changer les dimensions du rectangle. SizeX spécifie la largeur et le SizeY spécifie la hauteur. RoundLevel : Spécifie les niveaux d'arrondissage pour les quatre coins du rectangle. Une valeur de 0 ne signifie aucun arrondissage. Une valeur de 100 signifie que les coins seront complétement arrondie. Voir la documentation de la commande @{"Box()" LINK Box}. * * * Les calques de type #CIRCLE acceptent les éléments de modèle additionnels suivants: Radius: Spécifie le rayon du cercle. Plus d'informations disponibles dans la documentation de la commande @{"Circle()" LINK Circle}. * * * Les calques de type #ELLIPSE acceptent les éléments de modèle additionnels suivants: RadiusA : ces deux valeurs spécifient les rayons de x et y de l'ellipse. RadiusB Voir la documentation de la commande @{"Ellipse()" LINK Ellipse}. * * * Les caqlues de type #LINE acceptent les éléments de modèle additionnels suivants: Thickness : Spécifie l'épaisseur de la ligne. Plus d'information peuvent être trouvé dans la documentation de la commande @{"Line()" LINK Line}. * * * Les calques de type #POLYGON acceptent les éléments de modèle additionnels suivants: Vertices: Cet élément de modèle peut être utilisé pour changer l'apparence du polygone en lui indiquant un nouvel ensemble de sommets. Vous avez pour régler cet élément de modèle un tableau de sommets contenant une séquance de y de x et où les deux coordonnées qui définissent un sommet. Il utilise le même format que la commande @{"Polygon()" LINK Polygon} sauf que vous n'avez pas à spécifier le nombre de sommets dans le tableau. SetLayerStyle() détermine ceci automatiquement. * * * les calques #PRINT, #TEXTOUT et #TEXTOBJECT identifient les éléments de modèle suivant: Color : Spécifie la couleur du texte dans un format @{"ARGB" LINK ARGBInfo}. FontStyle : Ceci vous permet de changer le modèle de police du calque. Vous pouvez indiquer ici un ou plusieurs modèles. Si vous indiquez plusieurs polices de caractéres, vous devez utiliser l'opérateur OR (|). Pour les combinaisons possibles lire la documentation de la commande @{"SetFontStyle()" LINK SetFontStyle}. Si vous voulez enlever un modèle de police d'un calque utiliser l'élément "FontStyleClear". FontStyleClear : Tous les modèles de police que vous indiquez dans cet élément seront enlevé du calque. Les modèles multipolices doivent être séparé par l'opérateur OU (|). C'est l'inverse de l'élément "FontStyle". ShadowDir : Spécifie la direction de l'ombre pour ce calque. Seulement utilisé si le modèle de police est #SHADOW. ShadowColor : Spécifie la couleur de l'ombre pour ce calque. Seulement utilisé si le modèle de police est #SHADOW. ShadowSize : Spécifie la taille de l'ombre pour ce calque. Seulement utilisé si le modèle de police est #SHADOW. EdgeColor : Spécifie la couleur du contour pour ce calque. Seulement utilisé si le modèle de police est #EDGE. EdgeSize : Spécifie la taille du contour pour ce calque. Seulement utilisé si le modèle de police est #EDGE. Font : Vous pouvez utiliser cet élément de modèle pour changer la police du calque texte. Voir la documentation de @{"SetFont()" LINK SetFont}. FontSize : Vous pouvez utiliser cet élément de modèle pour changer la taille de la police du calque texte spécifié. Voir la documentation de @{"SetFont()" LINK SetFont}. Text : Cet élément de modèle vous permet de changer le contenu du calque texte. Vous pouvez remplacer l'ancien contenu en totalité du calque avec un nouveau texte. Align : Vous permet de changer l'alignement des textes aprés un caractére NL. Les valeurs possibles sont #LEFT, #RIGHT, et #CENTER. L'alignement par défaut est #CENTER. LeftMargin : Vous permet de changer les dimension de marge du calque RightMargin textes courant. "LeftMargin" est seulement utilisé pour les calques de type #PRINT mais "RightMargin" peut également être utilisé pour des objets textes et calques #TEXTOUT. Voir la documentation de @{"SetMargins()" LINK SetMargins}. @{b}INPUTS@{ub} id1 - identification du calque que vous voulez changer style1 - tableau contenant un ou plusieurs éléments de modèle depuis la liste au-dessus ... - optionnel : vous pouvez répéter la séquance id/style aussi souvent que vous en avez besoin ainsi vous pouvez modifier les modèles de plusieurs calques avec juste un seul appel @{b}EXEMPLE@{ub} SetLayerStyle(1, {x = #LEFT, y = #TOP}, 4, {x = #CENTER, y = #CENTER}, 5, {x = #RIGHT, y = #BOTTOM}, "mylayer", {x = 100, y = 100}) Le code ci-dessus change la position de plusieurs calques. Le calque 1 est déplacée au coin supérieur gauche, le calque 4 au centre, le calque 5 au coin inférieur droit et le calque "mylayer" est déplacé à 100:100. *** Box(0, 0, 100, 100, #BLUE) WaitLeftMouse SetLayerStyle(1, {Color = #RED}) Le code ci-dessus trace un carré bleu sur l'écran, attend un clique gauche de la souris gauche et change la couleur du carré en rouge. *** SetLayerStyle(1, {Frame = 0}) Le code ci-dessus affiche la prochaine image du calque 1 (qui doit être de type #ANIM). *** Polygon(#CENTER, #CENTER, {0, 0, 319, 0, 319, 159, 0, 159}, 4, #RED) WaitLeftMouse SetLayerStyle(1, {Vertices = {0, 159, 160, 0, 319, 159}, Color = #YELLOW}) Le code ci-dessus trace un polygone rectangulaire rouge, attend un clique gauche de la souris et change alors le polygone rectangulaire en polygone triangulaire jaune. @ENDNODE @NODE GetLayerStyle "Guide Hollywood" @{b}NOM@{ub} GetLayerStyle -- obtenir le modèle d'un calque (V4.0) @{b}SYNOPSIS@{ub} t = GetLayerStyle(id) @{b}FONCTION@{ub} Cette commande retourne tous les attributs de modèle du calque spécifié. Les différents attributs sont retournés dans un tableau que vous pouvez alors examiner. Le contenu du tableau de modèle retourné par cette commande dépend du type du calque que vous avez spécifiée. Pour une vue d'ensemble compléte de tous les éléments de modèles qui seront retournés par cette commande, voir la documentation de la commande @{"SetLayerStyle()" LINK SetLayerStyle} qui contient une liste des éléments de modèle de calque et à quels types de calque ils s'appliquent. Noter que cette commande interroge toujours tous les attributs et c'est pour cela qu'elle peut parfois être lente. Si vous avez besoin seulement de quelques informations de base au sujet d'un calque, utiliser @{"GetAttribute()" LINK GetAttribute} à la place. @{b}INPUTS@{ub} id - identification du calque à examiner @{b}RESULTAT@{ub} t - un tableau contenant tous les attributs de modèle pour ce calque @{b}EXEMPLE@{ub} t = GetLayerStyle(1) Print("Ce calque est à la position", t.x, ":", t.y, "!") Le code ci-dessus interroge le modèle du calque 1 et affiche sa position. @ENDNODE @NODE DisplayAnimFrame "Guide Hollywood" @{b}NOM@{ub} DisplayAnimFrame -- Afficher une image d'une animation (V4.0) @{b}SYNOPSIS@{ub} DisplayAnimFrame(id, x, y, frame[, filter]) @{b}FONCTION@{ub} Cette commande affiche une seule image d'une animation aux coordonnées spécifées. Nouveau depuis Hollywood 4.0: Vous pouvez spécifier un tableau optionnel contenant un ou plusiers filtres à appliquer à l'image avant de l'afficher. Voir @{"ici" LINK FilterTable} pour plus d'information sur le tableau de filtre. @{b}INPUTS@{ub} id - identification de l'animation à utiliser x - Destination en x y - Destination en y frame - image de l'animation à afficher (1 = première image) filter - optionnel: tableau contenant des filtres à appliquer à l'image de animation. @{b}EXEMPLE@{ub} DisplayAnimFrame(1, #CENTER, #CENTER, 5) Le code ci-dessus affiche l'image 5 de l'animation 1 au centre de l'écran. @ENDNODE @NODE AsyncDrawFrame "Guide Hollywood" @{b}NOM@{ub} AsyncDrawFrame -- tracer la prochaine image d'un objet asynchrone (V4.0) @{b}SYNOPSIS@{ub} finish = AsyncDrawFrame(id) @{b}FONCTION@{ub} Cette commande peut être utilisée pour tracer la prochaine image d'un objet asynchrone créé par une commande d'effet de la bibliothèque de transition ou de déplacement. AsyncDrawFrame() retourne FALSE si il y a des images dans la file d'attente. Vous devez exécuter cette commande jusqu'à ce qu'il retroune TRUE, cela signifie que vous avez tracé toutes les images qui étaient dans la file d'attente de l'objet asynchrone. Quand cette commande renvoie TRUE, elle supprime automatiquement le traçage d'objet asynchrone de sorte qu'il ne soit plus valide et ne puisse plus être utilisé. Si vous souhaiter arrêter une séquence de traçage asynchrones avant que toutes les images aient été tracé, utiliser la commande @{"CancelAsyncDraw()" LINK CancelAsyncDraw}. Noter qu'actuellement quelques restrictions s'appliquent à cette commande: 1.) Les images asynchrones peuvent seulement être tracé dans l'écran principal. Actuellement, vous ne pouvez pas utiliser cette commande pour tracer dans les brosses. 2.) Tant qu'il y a le traçage d'objets asynchrones, vous ne pouvez pas commuter le mode de calque. Les exécutions de @{"EnableLayers()" LINK EnableLayers} ou @{"DisableLayers()" LINK DisableLayers} seront désactivés tant que le traçage d'objets asynchrones sera activé. 3.) Vous ne pouvez pas commuter des images de fond tant que le traçage d'objets asynchrones sera activé. @{b}INPUTS@{ub} id - identification de l'objet asynchrone à utiliser @{b}RESULTAT@{ub} finish - FALSE s'il y a plus d'images à dessiné ou TRUE si l'objet asynchrone a fini @{b}EXEMPLE@{ub} obj = DisplayBrushFX(1, #CENTER, #CENTER, {Type = #WATER1, Async = True}) Repeat done = AsyncDrawFrame(obj) VWait Until done = True Le code ci-dessus affiche la brosse 1 au centre de l'écran avec l'effet de transition #WATER1. Comme vous pouvez le voir, l'effet n'est pas affiché par @{"DisplayBrushFX ()" LIENT DisplayBrushFX} mais dans la boucle d'AsyncDrawFrame () de sorte que vous puissiez effectuer une autre opération pendant l'effet de transition. @ENDNODE @NODE CancelAsyncDraw "Guide Hollywood" @{b}NOM@{ub} CancelAsyncDraw -- annuler l'affichage d'objets asynchrone (V4.0) @{b}SYNOPSIS@{ub} CancelAsyncDraw(id) @{b}FONCTION@{ub} Cette commande peut être utilisée à l'annulation d'affichage d'objets asynchrone. Voir la documentation de @{"AsyncDrawFrame()" LINK AsyncDrawFrame} pour plus d'information. @{b}INPUTS@{ub} id - identification de l'objet à annulé @ENDNODE @NODE V6LibGfxBGPic "Guide Hollywood" @{b}Fonction image de fond@{ub} @{"Introduction " LINK BGPICIntroduction} Qu'est-ce qu'un écran? Qu'est-ce qu'une image de fond? @{"@BGPIC " LINK atBGPIC} précharger une image de fond pour un usage ultérieur (V2.0) @{"BGPicToBrush() " LINK BGPicToBrush} convertir une image de fond en brosse @{"CopyBGPic() " LINK CopyBGPic} copier une image de fond (V4.0) @{"CreateBGPic() " LINK CreateBGPic} créé une image de fond vide (V1.5) @{"CreateGradientBGPic() " LINK CreateGradientBGPic} créer une nouvelle image de fond avec un dégradé (V2.0) @{"CreateRainbowBGPic() " LINK CreateRainbowBGPic} créer une nouvelle image de fond avec un dégradé (V2.0) @{"CreateTexturedBGPic() " LINK CreateTexturedBGPic} créer une nouvelle image de fond avec comme texture une brosse @{"DisplayBGPic() " LINK DisplayBGPic} modifier l'image de fond @{"DisplayBGPicPart() " LINK DisplayBGPicPart} afficher une partie d'une image de fond @{"DisplayBGPicPartFX() " LINK DisplayBGPicPartFX} afficher une partie d'une image de fond avec une transition @{"DisplayTransitionFX() " LINK DisplayTransitionFX} changer l'image de fond en utilisant un effet de transition @{"FreeBGPic() " LINK FreeBGPic} libérer une image de fond @{"LoadBGPic() " LINK LoadBGPic} charger une image de fond @{"ScaleBGPic() " LINK ScaleBGPic} redimensionner une image de fond (V1.5) @{"SelectBGPic() " LINK SelectBGPic} sélectionner une image de fond comme périphérique de sortie (V1.5) @ENDNODE @NODE V6LibGfxDisplay "Guide Hollywood" @{b}Fonction affichage@{ub} @{"@DISPLAY " LINK atDISPLAY} Configurer vos écran @{"ChangeDisplaySize() " LINK ChangeDisplaySize} changer les dimensions de l'écran @{"EndSelect() " LINK EndSelect} sélectionner l'écran comme périphérique de sortie (V1.5) @{"HideDisplay() " LINK HideDisplay} cacher l'écran (V3.0) @{"MoveDisplay() " LINK MoveDisplay} déplacer l'affichage à une nouvelle position de l'écran (V2.0) @{"SetTitle() " LINK SetTitle} changer le titre de la fenêtre Hollywood @{"ShowDisplay() " LINK ShowDisplay} afficher un écran caché (V3.0) @ENDNODE @NODE V6LibGfxBrush "Hollywowod Guide" @{b}Fonction Brosse@{ub} @{"@BRUSH " LINK atBRUSH} précharger une brosse pour un usage ultérieur (V2.0) @{"BrushToBGPic() " LINK BrushToBGPic} convertir une brosse en image de fond @{"BrushToGray() " LINK BrushToGray} convertir une brosse en gris (V1.5) @{"ConvertToBrush() " LINK ConvertToBrush} convertir un objet en brosse (V2.5) @{"CopyBrush() " LINK CopyBrush} copier une brosse (V1.5) @{"CropBrush() " LINK CropBrush} couper une brosse (V2.0) @{"CreateBrush() " LINK CreateBrush} créer une brosse vide (V1.5) @{"DeleteAlphaChannel() " LINK DeleteAlphaChannel} retirer le canal alpha d'une brosse (V2.0) @{"DeleteMask() " LINK DeleteMask} retirer le masque d'une brosse (V2.0) @{"DisplayBrush() " LINK DisplayBrush} afficher une brosse @{"DisplayBrushFX() " LINK DisplayBrushFX} afficher une brosse avec des effets de transition @{"DisplayBrushPart() " LINK DisplayBrushPart} afficher une partie d'une brosse @{"FlipBrush() " LINK FlipBrush} renverser une brosse (V1.5) @{"FloodFill() " LINK FloodFill} remplir la zone de la brosse avec une couleur (V2.0) @{"FreeBrush() " LINK FreeBrush} libérer une brosse @{"GetBrushLink() " LINK GetBrushLink} obtenir un lien pour une brosse (V1.5) @{"InvertAlphaChannel() " LINK InvertAlphaChannel} inverser le canal alpha d'une brosse (V2.0) @{"InvertBrush() " LINK InvertBrush} inverser les couleurs d'une brosse (V1.5) @{"InvertMask() " LINK InvertMask} inverser un masque de brosse (V2.0) @{"LoadBrush() " LINK LoadBrush} charger une brosse @{"MixBrush() " LINK MixBrush} mélanger 2 brosses (V1.5) @{"MoveBrush() " LINK MoveBrush} déplacer une brosse de a à b @{"ReplaceColors() " LINK ReplaceColors} changer les couleurs dans une brosse (V1.5) @{"RotateBrush() " LINK RotateBrush} pivoter une brosse (V1.5) @{"SaveBrush() " LINK SaveBrush} sauvegarder une brosse dans un fichier (V2.0) @{"ScaleBrush() " LINK ScaleBrush} redimensionner une brosse @{"SelectAlphaChannel() " LINK SelectAlphaChannel} sélectionner le canal alpha d'une brosse comme périphérique de sortie vidéo (V2.0) @{"SelectBrush() " LINK SelectBrush} sélectionner une brosse comme périphérique de sortie (V1.5) @{"SelectMask() " LINK SelectMask} sélectionner le masque d'une brosse comme périphérique de sortie vidéo (V2.0) @{"SetAlphaIntensity() " LINK SetAlphaIntensity} définir l'intensité du canal alpha généré (V2.0) @{"SetBrushTransparency() " LINK SetBrushTransparency} définir la couleur transparente d'une brosse (V1.5) @{"SetMaskMode() " LINK SetMaskMode} définir le mode de rendu des masques (V2.0) @{"TintBrush() " LINK TintBrush} teinter une brosse (V1.5) @ENDNODE @NODE V6LibGfxAnim "Guide Hollywood" @{b}Fonction animation@{ub} @{"@ANIM " LINK atANIM} précharger une animation pour un usage ultérieur (V2.0) @{"CopyAnim() " LINK CopyAnim} copier une animation (V2.0) @{"CreateAnim() " LINK CreateAnim} créer une animation depuis une brosse (V2.0) @{"DisplayAnimFrame() " LINK DisplayAnimFrame} afficher une image d'une animation (V4.0) @{"FreeAnim() " LINK FreeAnim} libérer une animation @{"GetAnimFrame() " LINK GetAnimFrame} copier l'image d'une animation dans une brosse (V3.0) @{"IsAnim() " LINK IsAnim} déterminer si une animation est dans un format supporté @{"LoadAnim() " LINK LoadAnim} charger une animation @{"LoadAnimFrame() " LINK LoadAnimFrame} charger une image d'une animation (V1.5) @{"MoveAnim() " LINK MoveAnim} déplacer une animation de a à b @{"PlayAnim() " LINK PlayAnim} Jouer une animation @{"PlayAnimDisk() " LINK PlayAnimDisk} jouer une animation directement à partir du disque (V1.5) @{"ScaleAnim() " LINK ScaleAnim} redimensionner une animation @{"StopAnim() " LINK StopAnim} arrêter une animation en cours (V1.0) @ENDNODE @NODE V6LibGfxLayer "Guide Hollywood" @{b}Fonction calque@{ub} @{"Introduction " LINK LayersIntroduction} Qu'est-ce qu'un calque? Lire en premier. @{"AddMove() " LINK AddMove} ajouter un objet dans la liste de mouvement (V1.5) @{"ClearMove() " LINK ClearMove} efface la liste de mouvement (V1.5) @{"DisableLayers() " LINK DisableLayers} désactiver le système de calque (V1.5) @{"DoMove() " LINK DoMove} afficher une liste de mouvement (V1.5) @{"EnableLayers() " LINK EnableLayers} activé le système de calque (V1.5) @{"FreeLayers() " LINK FreeLayers} libèrer les calques de l'image de fond (V1.5) @{"GetLayerStyle() " LINK GetLayerStyle} obtenir le modèle d'un calque (V4.0) @{"HideLayer() " LINK HideLayer} cacher un calque (V1.5) @{"HideLayerFX() " LINK HideLayerFX} cacher un calque avec un effet de transition (V1.9) @{"InsertLayer() " LINK InsertLayer} insérer un nouveau calque (V1.5) @{"MoveLayer() " LINK MoveLayer} déplacer un calque de a à b (V1.9) @{"NextFrame() " LINK NextFrame} afficher une nouvelle image d'une animation de calque (V2.0) @{"RemoveLayer() " LINK RemoveLayer} effacer un calque (V1.5) @{"RemoveLayerFX() " LINK RemoveLayerFX} enlever un calque avec un effet de transition (V3.0) @{"RotateLayer() " LINK RotateLayer} pivoter un calque (V4.0) @{"ScaleLayer() " LINK ScaleLayer} redimensionner un calque (V4.0) @{"SetLayerLight() " LINK SetLayerLight} régler la luminositée sur un calque (V2.0) @{"SetLayerName() " LINK SetLayerName} affecter un nom à un calque (V2.0) @{"SetLayerStyle() " LINK SetLayerStyle} changer le modèle d'un ou plusieurs calques (V4.0) @{"SetLayerTint() " LINK SetLayerTint} régler la luminositée sur un calque (V2.0) @{"SetLayerTransparency() " LINK SetLayerTransparency} régler la transparence d'un calque (V1.5) @{"ShowLayer() " LINK ShowLayer} afficher ou déplacer un calque (V1.5) @{"ShowLayerFX() " LINK ShowLayerFX} afficher un calque cachée avec un effet de transition (V1.9) @{"SwapLayers() " LINK SwapLayers} échanger les positions de deux calques (V1.5) @{"Undo() " LINK Undo} défaire une opération graphique (V1.5) @{"UndoFX() " LINK UndoFX} défaire une opération graphique avec la transition fx (V1.5) @ENDNODE @NODE V6LibGfxDraw "Guide Hollywood" @{b}Fonction graphisme primitif@{ub} @{"Arc() " LINK Arc} tracer une partie d'ellipse (V2.0) @{"Box() " LINK Box} tracer un cadre @{"Circle() " LINK Circle} tracer un cercle @{"Cls() " LINK Cls} effacer l'écran (V2.0) @{"Ellipse() " LINK Ellipse} tracer une ellipse @{"Line() " LINK Line} tracer une ligne @{"Polygon() " LINK Polygon} tracer un polygone (V1.9) @{"Plot() " LINK Plot} tracer un pixel @{"ReadPixel() " LINK ReadPixel} lire un pixel sur le périphérique de sortie (V1.5) @{"SetFillStyle() " LINK SetFillStyle} définir le style de remplissage pour les commandes graphiques (V1.5) @{"SetFormStyle() " LINK SetFormStyle} définir le modèle de forme pour les primitives graphiques (V2.5) @ENDNODE @NODE V6LibGfxSprite "Guide Hollywood" @{b}Fonction sprite@{ub} @{"Introduction " LINK SpritesIntroduction} Qu'est-ce qu'un sprite? Lire en premier. @{"@SPRITE " LINK atSPRITE} précharger un sprite pour un usage ultérieur (V2.0) @{"CopySprite() " LINK CopySprite} copier un sprite (V2.0) @{"CreateSprite() " LINK CreateSprite} créer un sprite (V2.0) @{"DisplaySprite() " LINK DisplaySprite} afficher un sprite (V2.0) @{"FlipSprite() " LINK FlipSprite} renverser un sprite (V2.0) @{"FreeSprite() " LINK FreeSprite} libérer un sprite (V2.0) @{"LoadSprite() " LINK LoadSprite} charger un sprite (V2.0) @{"MoveSprite() " LINK MoveSprite} déplacer un sprite de a à b (V2.0) @{"RemoveSprite() " LINK RemoveSprite} enlever un sprite de l'écran (V2.0) @{"RemoveSprites() " LINK RemoveSprites} enlever tous les sprites de l'écran (V2.0) @{"ScaleSprite() " LINK ScaleSprite} redimensionner un sprite (V2.0) @ENDNODE @NODE V6LibGfxDoublebuffer "Guide Hollywood" @{b}Fonction double buffer@{ub} @{"BeginDoubleBuffer() " LINK BeginDoubleBuffer} activer le mode double buffer (V2.0) @{"EndDoubleBuffer() " LINK EndDoubleBuffer} désactive le mode double buffer (V2.0) @{"Flip() " LINK Flip} Commuter les écrans avant et arriére (V2.0) @ENDNODE @NODE V6LibGfxMisc "Guide Hollywood" @{b}Fonctions diverses@{ub} @{"ARGB() " LINK ARGB} composer une couleur avec la transparence alpha (V2.0) @{"AsyncDrawFrame() " LINK AsyncDrawFrame} afficher la prochaine image d'un objet asynchrone (V4.0) @{"Blue() " LINK Blue} obtenir la partie bleu d'une couleur (V1.9) @{"CancelAsyncDraw() " LINK CancelAsyncDraw} annuler l'affichage d'objets asynchrone (V4.0) @{"Collision() " LINK Collision} vérifier si deux objets se touche (V2.0) @{"CreateClipRegion() " LINK CreateClipRegion} créer une région de clip (V2.0) @{"DisablePrecalculation() " LINK DisablePrecalculation} désactiver la pré-calculation (V1.5 seulement) @{"EnablePrecalculation() " LINK EnablePrecalculation} activer la pré-calculation (V1.5 seulement) @{"FreeClipRegion() " LINK FreeClipRegion} libérer une région de clip (V2.0) @{"GetAttribute() " LINK GetAttribute} obtenir des informations sur un objet @{"GetRandomFX() " LINK GetRandomFX} choisir un effet de transition de façon aléatoire (V4.0) @{"GetRealColor() " LINK GetRealColor} connaître la représentation d'une couleur sur l'écran (V1.5) @{"Green() " LINK Green} obtenir la partie verte d'une couleur (V1.9) @{"IsPicture() " LINK IsPicture} déterminer si une image est dans un format supporté @{"MixRGB() " LINK MixRGB} mélanger 2 couleurs (V2.0) @{"Red() " LINK Red} obtenir la partie rouge d'une couleur (V1.9) @{"RGB() " LINK RGB} composer une couleur (V1.9) @{"SaveSnapshot() " LINK SaveSnapshot} effectuer une copie d'écran actuellement affiché (V2.0) @{"SetClipRegion() " LINK SetClipRegion} activer une région (V2.0) @{"VWait() " LINK VWait} attendre un vide vertical @ENDNODE @NODE V6LibGfx "Guide Hollywood" @{b}Bibliothèque graphique@{ub} La bibliothèque graphique est le coeur de l'application Hollywood. Elle fournit un grand nombre de fonction et de commande qui vous permet de créer simplement des applications puissantes avec des effets et des graphismes moderne. @{"Fonction graphisme primitif " LINK V6LibGfxDraw} Rectangles, lignes, cercles, polygones @{"Fonction image de fond " LINK V6LibGfxBGPic} Tous sur les images de fond @{"Fonction affichage " LINK V6LibGfxDisplay} Commande pour gérer votre affichage @{"Fonction brosse " LINK V6LibGfxBrush} Commande de contrôle des brosses @{"Fonction animation " LINK V6LibGfxAnim} Commande de gestion des animations @{"Fonction calque " LINK V6LibGfxLayer} Commande de contrôle des calques @{"Fonction sprite " LINK V6LibGfxSprite} Commande de contrôle des sprites @{"Fonctions diverses " LINK V6LibGfxMisc} Détection de collision et autres fonctions @ENDNODE @NODE TextHeight "Guide Hollywood" @{b}NOM@{ub} TextHeight -- renvoyer la longueur d'une chaîne (V1.5) @{b}SYNOPSIS@{ub} height=TextHeight(string$) @{b}FONCTION@{ub} Cette commande renvoie la longueur du texte spécifié par string$ si il était afficher sur l'écran. Il prend en compte la police de caractère sélectionnée et le type de police de caractère. @{b}INPUTS@{ub} string$ - texte source @{b}RESULTATS@{ub} height - longueur du texte @{b}EXEMPLE@{ub} height=TextWidth("Hello World") pos = (480 - height) / 2 Locate(0, pos) Print("Hello World") Le code ci-dessus centre le texte "Hello World" verticalement sur un écran X x 480. @ENDNODE @NODE AddTab "Guide Hollywood" @{b}NOM@{ub} AddTab -- ajouter une tabulation @{b}SYNOPSIS@{ub} AddTab(pos, ...) @{b}FONCTION@{ub} Cette commande ajoute une tabulation spécifiée par la position pos à la liste de tabulation Hollywood. Les tabulations peuvent seulement être utilisés avec la commande @{"Print()" LINK Print}. Si il y a un caractère de tabulation dans une chaîne qui est indiqué dans la commande @{"Print()" LINK Print}, alors elle se déplacera vers la prochaine position de tabulation. Vous pouvez initialiser les réglages de tabulation en utilisant @{"ResetTabs()" LINK ResetTabs}. Nouveau dans la V2.0 : Vous pouvez insérer autant de positions de tabulation dans cette commande que vous le désiré. @{b}INPUTS@{ub} pos - position de la nouvelle tabulation (en Pixel) ... - plus de positions de tabulation (V2.0) @{b}EXEMPLE@{ub} AddTab(100, 200, 300, 400) SetFontStyle(#UNDERLINED) NPrint("Last name\\tFirst name\\tAge\\tGender\\n") SetFontStyle(#NORMAL) NPrint("Doe\\tJon\\t34\\tMale") NPrint("Smith\\tMaggie\\t25\\tFemale") NPrint("...\\t...\\t...\\t...") Le code ci-dessus affiche un tableau en utilisant les tabulations. @ENDNODE @NODE ResetTabs "Guide Hollywood" @{b}NOM@{ub} ResetTabs -- initialiser les réglages de tabulation @{b}SYNOPSIS@{ub} ResetTabs() @{b}FONCTION@{ub} Cette commande initialise tous les réglages précédents de tabulation et les règles avec la valeur par défaut (une tabulation est converti en 8 espaces). Il n'y a aucune commande pour retirer une seul tabulation, donc si vous voulez effectué ceci, vous devez appeler cette commande et ajouter toutes les tabulations avec @{"AddTab()" LINK AddTab} excepté celui que vous voulez retirer. @{b}INPUTS@{ub} aucun @ENDNODE @NODE SetMargins "Guide Hollywood" @{b}NOM@{ub} SetMargins -- définir les marges pour le texte affiché @{b}SYNOPSIS@{ub} SetMargins(left,right) @{b}FONCTION@{ub} Cette commande vous permet de définir les marges qui seront utilisés pour le texte à afficher en utilisant la commande @{"Print()" LINK Print}. C'est très utile si vous voulez seulement afficher le texte à un endroit particulier de votre écran. L'argument left spécifie l'extrémité gauche de la marge et l'argument right l'extrémité droite de votre écran. Le paramètre par défaut pour left est 0 et pour right la largeur de l'écran-1 @{b}INPUTS@{ub} left - extrémité gauche de la marge (en Pixel) right - extrémité droite de la marge (en Pixel) @{b}EXEMPLE@{ub} SetMargins(200,300) Print("Hello World. C'est mon premier programme qui utilise les marges.") Le code ci-dessus définit les marges 200 et 300, se qui signifie que la sortie du texte est seulement effectuée entre les Pixel 200 et 300. @ENDNODE @NODE TextOut "Guide Hollywood" @{b}NOM@{ub} TextOut -- positionner le texte de sortie à une position définie @{b}SYNOPSIS@{ub} TextOut(x, y, text$[, table]) [V4.0] TextOut(x, y, text$[, align, maxwidth]) [ancienne syntaxe jusqu'à Hollywood 3.1] @{b}FONCTION@{ub} Cette commande affiche le texte spécifié par text$ à une position spécifiée par les coordonnées X, Y. Cette commande a l'avantage que vous pouvez utiliser des constantes spéciales Hollywood comme coordonnées ( par exemple #CENTER, #BOTTOM... ) ce qui n'est pas possible avec @{"Print()" LINK Print} puisque la commande @{"Locate()" LINK Locate} ne les reconnaît pas. Depuis Hollywood 2.5, vous pouvez utiliser le @{"format des tags" LINK V6PrgFormatTags} dans la chaîne que vous insérez dans TextOut(). tags vous permet de contrôler le type de police de caractère et la couleur de votre texte à la volé (en temp réel). Le format tags commence et fini toujours par un crochet ("["). Au cas où vous voulez juste afficher un crochet, vous devrez utilisez deux [ . Si il y a seulement un crochet "[", Hollywood attendra toujours un format de tag. Voir le chapitre expliquant le @{"format des tags" LINK V6PrgFormatTags}. Dans Hollywood 4.0 la syntaxe de cette fonction a légèrement changé. L'ancienne syntaxe est encore compatible, les nouveaux scripts doivent utiliser la nouvelle syntaxe qui accepte un tableau comme argument 4. Le tableau peut contenir les éléments suivants : Align : permet de spécifier l'alignement des textes après un saut de ligne (peux être #LEFT, #CENTER, #RIGHT). La valeur par défaut est #LEFT. WordWrap : TextOut() peut effectuer un retour automatique à la ligne si vous spécifiez ce paramètre supplémentaire. Vous pouvez utiliser ce paramètre pour spécifier une largeur maximum de votre texte. TextOut() utilisera alors le retour automatique pour s'assurer qu'aucun texte ne s'affiche au delà de cette limite. Si vous ne réglez pas cet argument ou le réglez à 0 (qui est la valeur par défaut), le texte sera aussi large qu'il l'exige. En outre, vous pouvez également permettre le redimensionnement/ou la rotation des textes par le réglage d'éléments de filtres dans la table d'argument. Cliquer @{"ici" LINK FilterTable} pour plus d'information. @{b}INPUTS@{ub} X - position de x pour le texte y - position de y pour le texte text$ - chaîne de caractères à afficher table - optionnel: tableau contenant des paramètres supplémentaires de configuration (voir ci-dessus) (V4.0) @{b}EXEMPLE@{ub} TextOut(#CENTER, #CENTER, "Hello World!") WaitLeftMouse Undo(#TEXTOUT) Le code ci-dessus affiche "Hello World!" au centre de votre écran. Puis il attend un clic du bouton gauche de la souris et efface "Hello World" de l'écran. @ENDNODE @NODE DisplayTextObjectFX "Guide Hollywood" @{b}NOM@{ub} DisplayTextObjectFX -- afficher un objet textes avec des effets de transition @{b}SYNOPSIS@{ub} DisplayTextObjectFX(id, x, y[, table]) [V4.0] DisplayTextObjectFX(id, x, y[, type, speed, arg]) [ancienne syntaxe jusqu'à la version 3.1] @{b}FONCTION@{ub} Cette commande est une version étendue de la commande @{"DisplayTextObject()" LINK DisplayTextObject}. Il affiche l'objet textes spécifié par id à la position spécifié par x : y et utilise un des nombreux effets de transition d'Hollywood pour l'afficher. Vous devez également définir la vitesse spécifié par speed pour la transition. Depuis Hollywood 4.0 Cette commande utilise une nouvelle syntaxe avec juste un seul tableau (table) comme argument optionnel. L'ancienne syntaxe est encore compatible. L'argument optionnel table peut être utilisé pour configurer l'effet de transition. Les options suivantes sont possibles : Type : Spécifie l'effet souhaité pour le passage. Pour une liste de toute les effets de transition possible, voir la documentation de la commande @{"DisplayTransitionFX()" LINK DisplayTransitionFX}. (Valeur par défauts : #RANDOMEFFECT) Speed : Spécifie la vitesse désirée pour la transition. Plus la valeur que vous spécifiez ici sera élevé, plus l'effet sera rapide. (Valeur par défauts : #NORMALSPEED) Parameter : Quelques effets de transition ont un paramètre supplémentaire. ceux-ci sont spécifié ici. (Valeur par défauts : #RANDOMPARAMETER) Async : Vous pouvez utiliser cette option pour afficher un objet de manière asynchrone pour cette transition. Si vous mettez TRUE, DisplayTextObjectFX() s'arrêtera et redonnera la main afin de créer un traitement asynchrone à un objet que vous pouvez alors afficher en utilisant AsyncDrawFrame(). Veuillez lire la documentation de @{"AsyncDrawFrame()" LINK AsyncDrawFrame} pour plus d'information. @{b}INPUTS@{ub} id - identificateur de l'objet texte à afficher X - position désirée de x pour l'objet texte y - position désirée de y pour l'objet texte table - optionnel: configuration de l'effet de transition @{b}EXEMPLE@{ub} DisplayTextObjectFX(1, 0, 0, #VLINES, 10) ; ancienne syntaxe OU DisplayTextObjectFX(1, 0, 0, {Type = #VLINES, Speed = 10}); nouvelle syntaxe Le code ci-dessus affiche l'objet textes 1 à 0:0 avec un effet de transition #VLINES à la vitesse 10. @ENDNODE @NODE TextWidth "Guide Hollywood" @{b}NOM@{ub} TextWidth -- renvoyer la longueur d'une chaîne @{b}SYNOPSIS@{ub} width = TextWidth(string$) @{b}FONCTION@{ub} Cette commande renvoie la longueur du texte spécifié par string$ si il était affiché sur l'écran . Il prend en compte le format de la police sélectionnée et le type de police de caractère. Note : Cette commande renvoie le déplacement du curseur du texte. C'est souvent moins que se qu'occupe réellement le texte une fois afficher sur l'écran. Si vous avez besoin d'informations détaillées au sujet de la taille réelle d'un texte, utiliser la fonction @{"TextExtent()" LINK TextExtent}. @{b}INPUTS@{ub} string$ - texte source @{b}RESULTATS@{ub} width - longueur du texte @{b}EXEMPLE@{ub} width = TextWidth("Hello World") pos = (640 - width) / 2 Locate(pos, 0) Print("Hello World") Le code ci-dessus centre le texte "Hello World" horizontalement sur un écran de 640 x X. @ENDNODE @NODE CreateTextObject "Guide Hollywood" @{b}NOM@{ub} CreateTextObject -- créer un objet texte @{b}SYNOPSIS@{ub} [id] = CreateTextObject(id, text$[, align, maxwidth]) @{b}FONCTION@{ub} Cette commande créé un nouvel objet texte contenant les données spécifié par text$ et lui affecte l'id spécifié. Si vous indiquez @{"Nil" LINK V6PrgTypeNil} comme id CreateTextObject() choisira automatiquement une id vide et la renverra. Le texte est afficher dans la couleur utilisé avec la police de caractère sélectionné. L'avantage des objets textes comparés au texte normal (afficher via @{"Print()" LINK Print} par exemple), est que vous pouvez facilement positionner des objets textes sur l'écran, les retirer ou même les mettre en mouvement en utilisant @{"MoveTextObject()" LINK MoveTextObject}. Depuis Hollywood 1.5, CreateTextObject() accepte des paramètres optionnels supplémentaire qui vous permette de spécifier l'alignement du texte après un saut de ligne. Depuis Hollywood 2.5, CreateTextObject() accepte le paramètre supplémentaire "maxwidth". Vous pouvez utiliser ce paramètre pour spécifier une largeur maximum pour cet objet texte. CreateTextObject() utilisera alors un retour automatique à la ligne pour s'assurer qu'aucun texte ne soit affiché au delà de cette limite. Si vous laisser cet argument à 0 (qui est également la valeur par défaut), l'objet texte sera aussi large que le texte lui même. Depuis Hollywood 2.5, vous pouvez utiliser @{"les formats tags" LINK V6PrgFormatTags} dans la chaîne que vous créez via CreateTextObject(). ces tags vous permettent de contrôler le style de police de caractères et la couleur de votre texte à la volé (en temp réel). Le format tags commence et se termine toujours avec un crochet ("["). Au cas où vous voudriez juste afficher un crochet "[", vous devrez utiliser deux crochets. S'il y a seulement un crochet, Hollywood attendra toujours un format de tags. Voir le chapitre au sujet du @{"format tags" LINK V6PrgFormatTags} pour plus d'informations. @{b}INPUTS@{ub} id - identification du nouvel objet texte ou @{"Nil" LINK V6PrgTypeNil} pour la @{"Sélection automatique d'id" LINK AutoIDSelect} text$ - texte pour l'objet texte align - optionnel: alignement du texte après un de saut de ligne ; peut être réglé avec #LEFT, #CENTER, #RIGHT ; défauts : #LEFT (V1.5) maxwidth - optionnel: largeur maximum pour cet objet texte (V2.5) @{b}RESULTATS@{ub} id - optionnel: identificateur de l'objet texte ; sera seulement retourné quand vous utilisez @{"Nil" LINK V6PrgTypeNil} comme argument 1 (voir ci-dessus) @{b}EXEMPLE@{ub} SetFontColor(#RED) SetFont("times.font", 18) CreateTextObject(1, "Hello World!") DisplayTextObject(1, #CENTER, #CENTER) Le code ci-dessus créé un objet texte avec la police de caractère "times" (taille 18) et avec la couleur rouge. Le texte est "Hello World". Après sa création, l'objet texte est affiché au centre de l'écran. @ENDNODE @NODE FreeTextObject "Guide Hollywood" @{b}NOM@{ub} FreeTextObject -- libérer un objet texte @{b}SYNOPSIS@{ub} FreeTextObject(id) @{b}FONCTION@{ub} Cette commande libère la mémoire de l'objet texte spécifié par id afin de réduire la consommation mémoire, vous devez libérer ces objets texte quand vous n'en avez plus l'utilité. @{b}INPUTS@{ub} id - identificateur pour l'objet texte @ENDNODE @NODE DisplayTextObject "Guide Hollywood" @{b}NOM@{ub} DisplayTextObject(id,x,y) -- afficher un objet texte @{b}SYNOPSIS@{ub} DisplayTextObject(id,x,y) @{b}FONCTION@{ub} Cette commande affiche un objet texte spécifié par id aux coordonnées spécifiées par x, Y. @{b}INPUTS@{ub} id - identification du texte à afficher X - position de x y - position de y @{b}EXEMPLE@{ub} voir @{"CreateTextObject()" LINK CreateTextObject} @ENDNODE @NODE Locate "Guide Hollywood" @{b}NOM@{ub} Locate -- régler la position du curseur @{b}SYNOPSIS@{ub} Locate(x,y) @{b}FONCTION@{ub} Cette commande positionne le curseur à x :y. La position du curseur est utilisée par la commande @{"Print" LINK Print} comme position où l'affichage commence. Note: Vous ne pouvez spécifier aucune des constantes spéciales Hollywood pour x ou y puisqu'il n'y a aucune largeur ou hauteur de référence, pour cette raison les choix tel que #CENTER, #BOTTOM, #RIGHT etc.. ne peuvent pas fonctionner. Si vous voulez utiliser ces constantes spéciales, utiliser la commande @{"TextOut()" LINK TextOut} pour afficher votre texte. @{b}INPUTS@{ub} X - nouvelle position désirée y - nouvelle position désirée @ENDNODE @NODE MoveTextObject "Guide Hollywood" @{b}NOM@{ub} MoveTextObject -- déplacer un objet texte de a à b @{b}SYNOPSIS@{ub} MoveTextObject(id, xa, ya, xb, yb[, table]) @{b}FONCTION@{ub} Cette commande déplace doucement (défilements) un objet texte spécifié par id de l'emplacement spécifié par xa, ya à l'emplacement spécifié par xb, yb. D'autres options de configuration sont possibles en utilisant l'argument optionnel table. Vous pouvez spécifier la vitesse de mouvement, un effet spécial, et si oui ou non le mouvement sera asynchrone. Voir la documentation de la commande @{"MoveBrush()" LINK MoveBrush} pour plus d'information. @{b}INPUTS@{ub} id - identification de l'objet texte à utiliser comme source xa - position de la source X ya - position de la source y xb - position de la destination X yb - position de la destination y table - optionnel: davantage d'option pour le mouvement @{b}EXEMPLE@{ub} MoveTextObject(1,100,50,0,50,{Speed = 5}) Déplace l'objet texte 1 de 100:50 à 0:50 avec la vitesse 5. @ENDNODE @NODE SetFont "Guide Hollywood" @{b}NOM@{ub} SetFont -- changer la police de caractère utilisé @{b}SYNOPSIS@{ub} SetFont(font$,size) @{b}FONCTION@{ub} Cette commande modifie la police de caractère utilisé à celle spécifié par font$ et size. La police de caractère en cours est utilisé par des commandes comme @{"Print()" LINK Print} mais également par @{"CreateTextObject()" LINK CreateTextObject}. Hollywood rechercherà la police de caractère dans le répertoire courant ainsi que dans le répertoire "fonts" et finalement dans le répertoire FONTS: . Le fichier de police de caractère peut être de n'importe qu'elle type comme TrueType, intellifont, bitmap ou une police de caractère en couleur. Le type de police de caractère sera remis à l'état initial en appelant cette commande. @{b}INPUTS@{ub} font$ - nom de la police de caractère à charger size - taille désirée de la police de caractère @{b}EXEMPLE@{ub} SetFont("times.font",18) Print("Hello World") Ce code sélectionne la police de caractère "times" avec la taille 18 et affiche "Hello World". @ENDNODE @NODE SetFontColor "Guide Hollywood" @{b}NOM@{ub} SetFontColor -- changer la couleur de la police de caractère actuelle @{b}SYNOPSIS@{ub} SetFontColor(color) @{b}FONCTION@{ub} Cette commande modifie la couleur de la police de caractère actuelle à celle spécifié par color, qui est dans une @{"valeur RGB" LINK RGBInfo}. depuis Hollywood 2.5 : La couleur peut également être en @{"valeur ARGB " LINK ARGBInfo} pour du texte en alpha-blended @{b}INPUTS@{ub} color - spécification de la couleur en @{"RGB" LINK RGBInfo} ou en @{"ARGB" LINK ARGBInfo} @{b}EXEMPLE@{ub} SetFontColor(#GRAY) Ce code sélectionne la couleur grise pour la police de caractère. SetFontColor(ARGB(128, #RED)) Le code ci-dessus sélectionne une couleur rouge de transparence pour la police. Le fond alors sera traversé par le texte à un taux de 50% (128=50% de 255). @ENDNODE @NODE SetFontStyle "Guide Hollywood" @{b}NOM@{ub} SetFontStyle -- changer le type de police de caractère @{b}SYNOPSIS@{ub} SetFontStyle(style, ...) SetFontStyle(#SHADOW, color, distance, direction) (V2.5) SetFontStyle(#EDGE, color, size) (V2.5) @{b}FONCTION@{ub} Cette commande modifie le type de police de caractère par celui qui est spécifié par style qui doit être une des constantes indiqué ci-dessous. L'argument style peut être l'une des constantes suivantes : #NORMAL - remettre à l'état initial le type de police de caractère #BOLD - régler le type de police de caractère en gras #ITALIC - régler le type de police de caractère en italique #UNDERLINED - régler le type de police de caractère à souligné #ANTIALIAS - régler le type de police de caractère a l'anticrénelage; Noter que l'anticrénelage est seulement disponible avec les police de caractères TrueType (V2.0) #SHADOW - régler le type de police de caractère pour ombrager; votre texte aura une ombre; le deuxième argument spécifie la couleur d'ombre; cette couleur peut être notifié en @{"RGB" LINK RGBInfo} ou en @{"ARGB" LINK ARGBInfo}; la transparence d'ombre est compatible; le troisième argument spécifie la distance de l'ombre du texte principal en Pixel; le quatrième argument spécifie le sens de l'ombre ; ceci doit être une des @{"constantes directionnelles" LINK V6PrgDirectionCst} (V2.5) #EDGE - régler le type de police de caractère pour entouré; une ligne spécifié par size sera dessiné autour de votre texte; le deuxième argument spécifie la couleur de la ligne; cette couleur peut être en notation @{"RGB" LINK RGBInfo} ou @{"ARGB" LINK ARGBInfo}; la transparence est compatible; le troisième argument spécifie l'épaisseur désirée de la ligne en Pixel (V2.5) Depuis Hollywood 2.0, vous pouvez spécifier plusieurs effets sur la police de caractères dans un seul appel simplement en les ajoutant avec les autres, par exemple un appel SetFontStyle (#BOLD|#ITALIC) réglerà la police de caractère à gras et italique. Evidemment, #NORMAL est exclusif et ne peut pas être combiné avec n'importe quel autre type. Noter également, que pour les styles qui exigent des arguments supplémentaires (c.-à-d. #SHADOW et #EDGE), qu'ils ne peuvent pas être combinés dans un seul appel puisque Hollywood ne saurait pas alors à quel type les arguments supplémentaires appartiennent. @{b}INPUTS@{ub} style - constante spéciale de style (voir la liste ci-dessus) ... - autres arguments optionnels dépendant du style sélectionné (voir ci-dessus) @{b}EXEMPLE@{ub} SetFontStyle(#BOLD|#ITALIC) Le code ci-dessus configure le type de police de caractère en gras et italique. SetFontStyle(#SHADOW, ARGB(128, $939393), 16, #SHDWSOUTHEAST) Le code ci-dessus valide un ombrage gris semi-transparent qui sera positionné à 16 Pixel au sud-est du texte principal. @ENDNODE @NODE Print "Guide Hollywood" @{b}NOM@{ub} Print -- afficher des données à l'écran @{b}SYNOPSIS@{ub} Print(var, ...) @{b}FONCTION@{ub} Affiche les données spécifiées par var à l'écran. Cette commande peut traiter tous les différents types de données, Vous pouvez afficher : des chaînes, nombres, tableaux, fonctions. La donnée est affiché à la position du curseur que vous pouvez modifier en utilisant la commande @{"Locate()" LINK Locate}. Cette commande utilise le retour automatique à la ligne, par exemple quand la marge est atteinte et qu'un mot ne peut pas être affiché dans la même ligne alors il fera un retour automatiquement. Vous pouvez régler manuellement les marges par en utilisant la commande @{"SetMargins()" LINK SetMargins}. Cette commande respecte également vos réglages de tabulation. Si vous affichez une chaîne de qui contient un caractère de tabulation (" \\t "), Print sautera dans la prochaine position de tabulation. Vous pouvez définir les réglages de tabulation avec les commandes @{"AddTab()" LINK AddTab} et @{"ResetTabs()" LINK ResetTabs}. Vous pouvez également spécifier des codes d'échappement ici. Voir le chapitre @{"type de donnée d'une chaîne" LINK V6PrgTypeString} pour plus d'information. Depuis Hollywood 2.0, vous pouvez utiliser autant d'arguments que vous le désirez avec cette commande. Si vous utilisez des arguments multiples avec cette commande, ils seront affichés avec un espace pour les séparer. Depuis Hollywood 2.5, vous pouvez utiliser @{"les format tags" LINK V6PrgFormatTags} dans la chaîne que vous utilisez dans Print(). En utilisant ces tags vous pouvez contrôler le style et la couleur de la police de caractère de votre texte à la volé (en temp réel). Le format tags commence et fini toujours par un crochet ("["). Au cas où vous voulez afficher un crochet, vous devrez utiliser deux crochet. S'il y a seulement un crochet, Hollywood attendra toujours un tags de format. Voir le chapitre @{"format tags" LINK V6PrgFormatTags} pour plus d'informations. A la place de Print(), vous pouvez également utiliser les commandes @{"NPrint()" LINK NPrint} et @{"TextOut()" LINK TextOut} pour afficher le texte à l'écran. @{b}INPUTS@{ub} var - données à afficher ... - autres arguments (V2.0) @{b}EXEMPLE@{ub} Print("Hello World!") @ENDNODE @NODE NPrint "Guide Hollywood" @{b}NOM@{ub} NPrint -- afficher les données et ajouter un retour à la ligne @{b}SYNOPSIS@{ub} NPrint(var, ...) @{b}FONCTION@{ub} Fait la même chose que @{"Print" LINK Print} mais ajoute un retour à la ligne à la fin. @{b}INPUTS@{ub} var - données à afficher ... - autres arguments (V2.0) @ENDNODE @NODE TextExtent "Guide Hollywood" @{b}NOM@{ub} TextExtent -- rechercher les informations détaillées au sujet d'une taille de texte (V2.5) @{b}SYNOPSIS@{ub} extent = TextExtent(string$) @{b}FONCTION@{ub} Cette commande renvoie les informations détaillées au sujet de la longueur de la chaîne spécifié avec les réglages de police de caractère et de style. Contrairement à @{"TextWidth()" LINK TextWidth}, qui renvoie seulement le déplacement du curseur TextExtent() renvoie l'encadrement exact pour la chaîne spécifié. Cette commande renvoie un tableau avec l'information dans les domaines suivants : MinX : Le décalage au côté gauche du rectangle. C'est souvent négatif. MinY : Le décalage de la base au haut du rectangle. C'est toujours négatif. MaxX : Le décalage au côté droit du rectangle. MaxY : Le décalage de la base au bas du rectangle. Width : C'est la même valeur que retourne @{"TextWidth()" LINK TextWidth}. Height : La même valeur que retourne @{"TextHeight()" LINK TextHeight}. Les valeurs dans MinX, MinY, MaxX, et MaxY sont toujours relative à la position actuelle du curseur. Par exemple, si MinX vaut -10, ceci signifie que @{"Print()" LINK Print} commencerait a afficher les Pixel de la chaîne à -10 pixels de la position du curseur sur l'axe des abscisses. La valeur dans "Width" spécifie où le curseur finirait après l'opération de rendu. C'est souvent moins que MaxX - 1. par exemple dans le cas du texte italique, le dernier caractère sera habituellement derrière la position finale du curseur. Pour calculer la longueur total de la chaîne spécifié, soustraire simplement MinX de MaxX et additionnert 1, c.-à-d. full_width = MaxX - MinX + 1. @{b}INPUTS@{ub} string$ - texte source @{b}RESULTATS@{ub} extent - les informations détaillées des dimensions du textes @ENDNODE @NODE ScaleTextObject "Guide Hollywood" @{b}NOM@{ub} ScaleTextObject -- redimensionner un objet texte (V4.0) @{b}SYNOPSIS@{ub} ScaleTextObject(id, width, height) @{b}FONCTION@{ub} Cette commande redimensionne l'objet texte spécifié par id en fonction de la largeur et la hauteur. Si l'objet texte utilise une police de caractère vectoriel, il n'y aura aucune perte de qualité. Vous pouvez utiliser le #KEEPASPRAT en tant que largeur ou hauteur. Hollywood calcule la taille automatiquement en prenant le ratio d'aspect de l'objet texte en considération. La largeur et la hauteur peuvent également être une chaîne contenant des spécifications en pourcentage, par exemple " 50% ". @{b}INPUTS@{ub} id - identification de l'objet texte à redimensionner width - nouvelle largeur désirée pour l'objet texte height - nouvelle hauteur désirée pour l'objet des texte @{b}EXEMPLE@{ub} ScaleTextObject(1, 600, 200) Redimensionne l'objet texte 1 à une dimension de 600x200. @ENDNODE @NODE CopyTextObject "Guide Hollywood" @{b}NOM@{ub} CopyTextObject -- copier un objet texte(V4.0) @{b}SYNOPSIS@{ub} CopyTextObject(source, dest) @{b}FONCTION@{ub} Cette commande copie l'objet texte spécifié par source et créé une copie comme objet texte dest. Le nouvel objet texte est indépendant de l'ancien objet texte ainsi vous pouvez libérer l'objet texte source après qu'il ait été copié. @{b}INPUTS@{ub} source - identification de l'objet texte source dest - identification de l'objet texte a créer @{b}EXEMPLE@{ub} CopyTextObject(1, 10) FreeTextObject(1) Le code ci-dessus créé un nouvel objet texte 10 qui contient les mêmes caractéristiques de dessins que objet texte 1. Il libère l'objet texte 1 parce qu'il n'est plus nécessaire. @ENDNODE @NODE RotateTextObject "Guide Hollywood" @{b}NOM@{ub} RotateTextObject -- effectuer une rotation à un objet texte(V4.0) @{b}SYNOPSIS@{ub} RotateTextObject(id, angle) @{b}FONCTION@{ub} Cette commande effectue une rotation à l'objet texte spécifié par id d'un angle spécifié par angle (en degrés). Un angle positif tourne dans le sens des aiguilles d'une montre, un angle négatif tourne dans le sens inverse des aiguilles d'une montre. Noter qu'actuellement la rotation du texte est implémentée en utilisant la rotation des Pixels ainsi vous remarquerez une perte de qualité quand le texte tourne. Dans les versions futures il est planifié d'utiliser la rotation vectoriel pour les polices de caractères TrueType ainsi il n'y aura plus aucune perte de qualité. @{b}INPUTS@{ub} id - identification de l'objet texte à tourner angle - angle désirée de rotation en degrés @ENDNODE @NODE V6LibTextFont "Guide Hollywood" @{b}Fonction police de caractère@{ub} @{"SetFont() " LINK SetFont} changer la police de caractère utilisé @{"SetFontColor() " LINK SetFontColor} changer la couleur de la police de caractère actuelle @{"SetFontStyle() " LINK SetFontStyle} changer le type de police de caractère @ENDNODE @NODE V6LibTextRender "Guide Hollywood" @{b}Fonction moteur d'affichage de text@{ub} @{"AddTab() " LINK AddTab} ajouter une tabulation @{"Locate() " LINK Locate} régler la position du curseur @{"NPrint() " LINK NPrint} afficher les données et ajouter un retour à la ligne @{"Print() " LINK Print} afficher des données à l'écran @{"ResetTabs() " LINK ResetTabs} initialiser les réglages de tabulation @{"SetMargins() " LINK SetMargins} définir les marges pour le texte affiché @{"TextExtent() " LINK TextExtent} rechercher les informations détaillées au sujet d'une tailles de texte (V2.5) @{"TextHeight() " LINK TextHeight} renvoyer la longueur d'une chaîne (V1.5) @{"TextOut() " LINK TextOut} positionner le texte de sortie à une position définie @{"TextWidth() " LINK TextWidth} renvoyer la longueur d'une chaîne @ENDNODE @NODE V6LibTextObject "Guide Hollywood" @{b}fonction objet texte@{ub} @{"CopyTextObject() " LINK CopyTextObject } copier un objet texte (V4.0) @{"CreateTextObject() " LINK CreateTextObject} créer un objet texte @{"DisplayTextObject() " LINK DisplayTextObject} afficher un objet texte @{"DisplayTextObjectFX() " LINK DisplayTextObjectFX} afficher un objet textes avec des effets de transition @{"FreeTextObject() " LINK FreeTextObject} libérer un objet texte @{"MoveTextObject() " LINK MoveTextObject} déplacer un objet texte de a à b @{"RotateTextObject() " LINK RotateTextObject } effectuer une rotation à un objet texte (V4.0) @{"ScaleTextObject() " LINK ScaleTextObject } redimensionner un objet texte (V4.0) @ENDNODE @NODE V6LibText "Guide Hollywood" @{b}Bibliothèque TEXTE@{ub} Hollywood fournit une bibliothèque texte moderne et qui vous permet d'afficher du texte sur votre écran avec des méthodes pratique. @{" Fonction police de caractère " LINK V6LibTextFont} Chargement des polices et format @{" Fonction moteur d'affichage de texte " LINK V6LibTextRender} Moteur d'affichage du texte @{" fonction objet texte " LINK V6LibTextObject} Comment créer un objet texte @ENDNODE @NODE History "Guide Hollywood" @{b}History In English... Sorry@{ub} Please read the history bottom-up. Note that the history might list some features that were implemented in beta versions and removed later but are still mentioned here. This history is a log of the programmer so that he can look up what has been done/tried/modified. Things that were implemented and removed later are marked with [VOID]. Version 4.0 (28-Feb-09) - Change: Updated Hollywood documentation - Change: Updated catalog descriptions and German translation; added new developer files for doing new translations - Change: Updated the Hollywood GUI; it now supports video export! - New: Added PointerDemo, MouseWheelDemo, AsyncFX, and LayerStyle examples - New: Added a nice little color matching game named Katica by Lazar Zoltan - New: Added SCUI Lib demos done by Fabio Falcucci - New: Added three new cracktros supplied by Mr. X of Barracuda; I find them really impressive and they surely show what you can do with Hollywood. Mr. X has ported the cracktros of PP Hammer, Moonstone, and Super Stardust. Big thanks mate! - Change: Added workaround for some strange behaviour in Windows Vista which could lead to Execute() failing on an existing program (reported by Torgeir Vee) - Fix: Pointer settings were lost after full screen switch via CMD+RETURN (reported by Lazar Zoltan) - New: Added VIDEOFPS argument for controlling the frames per second when in video recording mode - New: Added support for different video strategies using the VIDEOSTRATEGY argument - Fix: Ror() and Rol() were broken for #BYTE and #SHORT operand sizes - New: SetMaskMode() supports several new modes now: #MASKVANILLACOPY, #MASKOR, #MASKAND, #MASKXOR; can be used to achieve certain effects - Fix: Printing a string with newline characters only resulted in wrong cursor y position - Change: TextOut() uses a table as optional argument 4 now; old syntax still supported for compatibility - New: RotateTextObject() can be used to rotate text objects; currently, lossless vector transformation for true type fonts is not supported so rotating true type fonts doesn't deliver the best quality yet - New: DisplayBrush(), DisplayBrushPart(), DisplayAnimFrame(), TextOut() and PlayAnim() support a new optional filter argument now; if layers are enabled, the specified filters will automatically be applied to the layer - New: DisplayAnimFrame() allows you to display a single frame of an animation; if layers are enabled you will get layer of type #ANIM - Fix: GetAnimFrame() did not create independent graphics for non-disk anims - Fix [Amiga]: DEPTH argument was not always handled correctly (reported by Lazar Zoltan) - New: Attributes #ATTRFONTSCALABLE and #ATTRFONTAA can be used to query capabilities of the current font (requested by Lazar Zoltan) - New: AddMove() for type #LAYER now accepts a visibility flag (requested by Paul E. Bloedel) - Fix: ReplaceStr() could trash memory under certain circumstances (reported by Paul E. Bloedel) - Change: If Hollywood detects WinUAE USEWPA will be automatically enabled because it is faster under WinUAE - Change: ScaleLayer(), RotateLayer(), SetLayerTransparency(), SetLayerTint() simply call SetLayerStyle() now internally - New: Added RotateLayer() which allows you to rotate a layer - New: Added SetLayerStyle(); this is a very powerful function which allows you to change nearly all attributes of an existing layer on-the-fly; it can also scale and move layers; furthermore, you can change the style of multiple layers with only a single call; the attributes that can be specified depend on the type of the layer; see the documentation; you can use the new function GetLayerStyle() to query the current style flags of a layer - Fix: #ATTRWIDTH and #ATTRHEIGHT returned wrong values for #DISPLAY when SelectBrush(), SelectAlphaChannel() or SelectMask() were in use - New [Amiga]: DEBUGDEVICE argument can redirect output now to stdout or an ARexx Port (use @stdout or @rexx:PORTNAME) - Fix: ReadMem() and WriteMem() didn't advance file cursor correctly - New [Amiga]: StringRequest() uses requester.class now instead of reqtools.library (under OS4) - New: SystemRequest() accepts an optional argument now which allows you to specify an icon for the requester (not on all systems!) - New: [Amiga]: Added USEWPA and WPAMODE arguments; these arguments can be used to force Hollywood to work with pixel arrays instead of bitmaps; these are included mainly for overriding default settings that Hollywood chooses; you shouldn't use them unless you experience problems with the standard mode - Change [Amiga]: Datatype objects (pictures, samples, anims) are now loaded directly from memory using DTST_MEMORY if datatypes.library >= 44; speeds up things especially in compiled programs - Change [Amiga]: Hollywood's screen is now opened in the new OS4 style (reported by Paul E. Bloedel) - Change: F11, F12, Page Up, Page Down, Insert, Pause, Home, End keys are now also supported under OS4 - New: ChangeDisplaySize(), DisplayBGPic(), and DisplayTransitionFX() accept new optional arguments now that allow you to specify a new x & y position for the display (requested by Fabio Falcucci and Paul E. Bloedel) - New: IsKeyDown() also supports modifier keys like alt, control, shift etc. now - New: Added "OnWheelUp" and "OnWheelDown" event handlers for InstallEventHandler() (requested by Paul E. Bloedel) - New: Added WriteTable() and ReadTable() functions which allow for easily saving a whole table (including subtables and even user functions) to a file; ReadTable() can be used to load the table from disk (NB: if there are entries of type #USERDATA and #LIGHTUSERDATA they're written as #NUMBER with value 0) - New: GetRandomFX() returns a random effect from Hollywood's palette; this is useful if you cannot use #RANDOMEFFECT because you want to apply a filter - Change: Layer substitution mechanism is more sophisticated now & anim layers still work now even if their source anim is freed or scaled etc. - Change: CopyAnim() can also clone disk anims now - New: Added CopyTextObject() command - New: Added CopyBGPic() command; NB: this will only copy the graphics of the specified bgpic; layers, buttons, sprites etc. will not be copied - Fix: Layer substitution did not account for ScaleBGPic() - New: DefineVirtualFile() allows you to define virtual files that actually occupy a certain area in a real file; this is useful for reading from huge resource files; DefineVirtualFile() can be used with all Hollywood functions that take a filename - Change: All DOS functions work with files > 4 gigabyte now (except on AmigaOS Classic) - Fix [Amiga]: Harmless enforcer hit in the GUI (reported by Christian Kummerow) - Fix [Amiga]: Dead pointer access on music stream finish (reported by Janne Peräaho) - New: Added WriteFunction() and ReadFunction() commands which can be used to save and load Hollywood functions to/from files; this is a very cool feature and opens up a wide variety of possible uses; it is especially interesting for larger game projects which need a scripting engine; code from this engine could now be loaded from external files; functions can be saved to files using standard binary data or base64 encoding for embedding them in a text files - New: Added support for alpha blended 32-bit pointers; you can make these new pointers by converting brushes or sprites; simply use the function CreatePointer() to make a pointer from a brush/sprite source; FreePointer() frees pointers; NB: an API break was necessary: SetPointer() no longer accepts a file name but only a pointer id and you have to use CreatePointer() also for system & busy pointers (requested by Fabio Falcucci) - New: All commands that create new Hollywood objects (brushes, samples, files, text objects and many other types) accept NIL now in the object id parameter; if you pass NIL to an object creation function, it will automatically choose a vacant id for you and return it to you; this is very useful when working with larger scripts that use lots of different objects and ids - New: GetType() supports lua types #USERDATA, #LIGHTUSERDATA, and #THREAD now (#THREAD currently not available in Hollywood) - New: Added video recording mode! This is a very cool feature which allows you to record your Hollywood scripts as an AVI video; you can use the VIDEOOUT argument to activate the video recorder; you will get a fully featured AVI video file complete with video and audio stream; you can use one of the scaling engines to define the dimensions of your video (e.g. 720*576 for DVD) - New: The MoveXXX() functions and PlayAnim() also use a different syntax now and accept a table which allows you to use these functions asynchronously - New: Added support for asynchronous transition effects; all the commands that deal with transition effects use a different syntax now; a table is used to configure the effect and you can specify a table element "Async" which - if set to TRUE - returns a handle to a async draw object which you can then draw using AsyncDrawFrame(); this is useful if you want to do other things while displaying a transition effect; in particular, this opens many new possibilities for Hollywood Designer; to stop an async draw object you call CancelAsyncDraw() - New: Major rework of the transition fx library; transparency and tint settings are fully supported now; additionally, effects are displayed correctly now even if the layers are in background; layerscale and autoscale are fully supported - New: Added layerscale engine; this is powerful and required major rewritings of several essential parts of Hollywood but the layerscale engine paves the way for many cool features; in contrast to the autoscale engine, the layerscale engine will scale the individual layers on the display; this is much faster than the autoscale engine which always has to scale the whole screen even if only a few pixels have been modified; but the greatest advantage of the layerscale engine is that vector layers (vector text, gfx primitives) can be scaled infinitely without loss of quality; this is very useful e.g. to promote your presentation to large screenmodes etc.; you can activate the engine by using the LAYERSCALE argument; note that it's not possible to disable layers when the layerscale engine is active - New: Added autoscale engine; this engine allows you to promote your scripts to any dimensions you want without changing a single line of your code; Hollywood will mock your script into thinking that it is running in the usual dimensions but in reality, the script will be promoted to a new dimension; use the AUTOSCALE argument to activate this new mode; the SCALEWIDTH and SCALEHEIGHT arguments can be used to specify the desired dimensions (notation in percent also allowed); if you don't specify SCALEWIDTH and SCALEHEIGHT, autoscale will stay inactive until the user sizes the window; use the SMOOTHSCALE argument to toggle smooth scaling on and off - Fix: Special speed constants were not handled correctly when passed to PlayAnim(), PlayAnimDisk() and the "animspeed" parameter in MoveAnim() - Change: If the Hollywood window gets resized while a transition effect is in progress, the effect will be restarted (in case it's an object effect) or aborted (in case it's a BGPic transition); in previous versions, garbage was left on the screen if a window resize occurred during transition fx - Change [Amiga]: Alpha byte is always cleared out now; this is necessary because OS 4.1 seems to set it even if the image doesn't have an alpha channel (reported by Paul E. Bloedel) - Fix: RIFF WAVE streams were not closed correctly (reported by Lazar Zoltan) - Fix: Several fixes in connection with layers of type #BRUSHPART and #BGPICPART: Collision() did not work correctly with them; layer buttons that used pixel-exact collision detection did not work; ConvertToBrush() and GetBrushLink() did not work with layers of these types either - Change: Faster, non-copying SwapLayers() mechanism - New: Added OpenDirectory(), CloseDirectory() and NextDirectoryEntry() functions; you can use these for a more sophisticated control over directories (the old ReadDirectory() function can get quite slow with vast directories because it sorts all entries alphabetically); with NextDirectoryEntry() you'll receive files and directories in the order as returned by the file system - Fix: When used with a global iterator variable, the FOR statement did not work correctly in recursive functions (reported by Fabio Falcucci) - Fix [Win32]: HidePointer() and ShowPointer() did not work (reported by Lazar Zoltan) - Fix [Win32]: Mode setting specified in @DISPLAY was not handled correctly in applets/ executables (reported by Lazar Zoltan) - Fix [Win32]: #ATTRPOSITION did not return the correct time for musics after their first loop - Fix [MacOS]: CreateSample() did not work correctly - New: SaveBrush() and SaveSnapshot() can save JPEG images now; simply pass #IMGFMT_JPEG in the format parameter; there's an optional parameter which specifies the quality (ranging from 1 to 100) - Fix: #RANDOMEFFECT could accidentally choose the obsolete #TYPEWRITER effect which caused an error - Fix: #BLEND/#FADE reverse fx modes did not work correctly with HideLayerFX() and RemoveLayerFX() - New: Added funky reverse fx mode for #HSTRANGEPUSH and #VSTRANGEPUSH (finally...) - Fix: #STRETCHRIGHT and #STRETCHBOTTOM were broken since Hollywood 2.5 - Change: #HSTRANGEPUSH and #VSTRANGEPUSH look now much better when used with transparent objects (mask or alpha) - Change: When using DisplayTransitionFX() to switch to a BGPic that has a different size than the current BGPic, the current BGPic got automatically scaled to the dimensions of the new BGPic; this is no longer done in this way; of course, the current BGPic is still scaled to match the dimensions of the new one but this scaling is only temporary and doesn't change the BGPic - Change: Removed auto-scaling for double buffers; brand-new scaling engine is coming up! - Fix: Moving a layer using ShowLayer() or NextFrame() did not work while SelectBGPic() was active - New: FreeLayers() accepts an optional argument now which specifies whether to "keep" layers or not; defaults to TRUE for compatibility - Fix: FreeLayers() trashed Hollywood's internal refresh bitmap when used while SelectBGPic() was active - New: ScaleTextObject() allows you to scale text objects; text objects that use vector fonts can be scaled freely to any size including x/y distortion; note however that the desired pixel dimension you pass to ScaleTextObject() denotes only an approximation in case of vector fonts; the real resulting dimension might be a little bit bigger or smaller - New: A happy welcome to the 400th function of Hollywood: ScaleLayer()! - Fix: When using #NEXTFRAME with DoMove() on a non-existing anim layer the current frame argument was not handled correctly - Fix: DisplayTextObject() aligns the text now correctly taking any underhangs of characters into account - New: #ATTRTEXT returns the text of text objects or text layers - New: #ATTRFONTNAME, #ATTRFONTSIZE, #ATTRFONTASCENDER, #ATTRFONTDESCENDER can now be used with text objects as well as with text layers (layer types PRINT, TEXTOUT, TEXTOBJECT) - Change: SetLayerTint() does not cache the tinted graphics any longer but tints on the fly when needed; this is slower than the previous implementation but makes the source code much clearer :) - New: CompressFile() and DecompressFile() functions can be used to handle packed files easily; each function accepts two arguments which specify source and destination file; the return value is the size of the destination file - Fix [Win32]: Body text dimensions were not calculated correctly in the SystemRequest() and StringRequest() functions - Fix [MacOS]: Alpha channel was not always loaded correctly under Mac OS (reported by Janne Peräaho) - New: Added support for the Intel version of Mac OS X; You can compile executables for this platform by using "-exetype macos86" - Fix [Win32]: Sound buffer for playing Protracker was probably too small for some sound cards because there were glitches under Windows Vista; I've now doubled its size to 19200 bytes which is enough to carry 100 milliseconds of 48000hz, stereo, 16bit sampled Protracker sound; still very strange that the 50 milliseconds buffer was sufficient on my old PC but on my brand-new iMac using Vista it's too small - New: DisplayBGPicPart() can now also be used to copy the current display graphics to a brush; useful for saving certain areas in order to restore them later; just pass TRUE in the last parameter and make sure layers are off (requested by Fabio Falcucci) - New: Added OVERWRITE argument which forces Hollywood to always overwrite old files and directories when in compile mode - Change: When in compile mode, Hollywood will ask now before overwriting existing files; when creating Mac OS programs and the program already exists, Hollywood will delete the whole application bundle, so be careful! - Fix: ".app" is not appended twice to Mac OS programs any more; if it was already specified with -compile, it is no longer appended again - Fix [Amiga]: Switching between full screen and windowed modes using the hot key resulted in a crash inside a call to VWait(); this could happen quite often because Hollywood calls VWait() also internally - New: Added "Transparency", "ScalePicture", and "BrushFile" tags for the "Backfill" setting in @DISPLAY; the file specified in "BrushFile" will be linked to the applet/ executable unless "LinkBrushFile" is set to FALSE - Fix: "Mode" setting in @DISPLAY could be overridden by using tooltypes/command line (reported by Paul E. Bloedel) - Change [Win32]: Temporary files are now stored in the current user's temporary folder instead of in the root directory of the current drive - New: Added support for compressed applets; specify the COMPRESS argument to make Hollywood compress your applet - New: @INCLUDE can also import whole Hollywood applets into your script; applet objects like brushes, samples, etc. are imported too - Fix [Amiga]: Hollywood no longer tries to open keymap.library v39; it should work again now with Kickstart 3.0 which still contains a v37 keymap.library (reported by Lazar Zoltan) - Fix [Amiga]: Loading sounds through sound.datatype from applet or executable did not work (reported by Lazar Zoltan) - Fix [Win32]: Saving PNGs did not work - New: Added truetype font support for Win32 and Mac OS Version 3.1 (22-Mar-08) - Change: Updated Hollywood documentation - Change: Updated the Hollywood GUI - Fix [Win32/Mac]: Relative path names using "." and ".." are now resolved correctly when retrieving the "path" field of GetFileAttributes(); in v3.0 "path" still contained "." and ".."; now they are resolved correctly - New: Implemented userdata functionality; all functions that work with callback functions will now accept an additional parameter called "userdata" which will then be passed to the callback function as table field "userdata"; this parameter can be of any type; userdata is useful if you want to avoid to work with global variables; the following functions accept the userdata parameter: MakeButton(), InstallEventHandler(), SetTimeout(), SetInterval(), CopyFile(), DeleteFile() - New: Implemented a convenient way to use methods: When you define and call functions using a colon (:) instead of a dot (.) the function will receive an invisible parameter called "self" which refers to the object that the function belongs to; this is very useful for object oriented programming with Hollywood; unfortunately, this change conflicts with the Hollywood 1.x emulator which uses the colon to separate multiple commands on the same line so you will need to adapt your 1.x scripts if you are still using the colon in that way (requested by Dwayne L. Jarvis) - Fix: Severe bug in the virtual machine caused an endless loop when a generic for that ended with a conditional statement was used (reported by Dwayne L. Jarvis) - Fix: OP_NOT and OP_TEST did not accept tables and functions as arguments which could lead to problems when trying to use stuff like "o = o OR {}" with "o" being a table - New: #ATTRFONTNAME and #ATTRFONTSIZE can be queried by passing them to GetAttribute() together with #DISPLAY (requested by Jesper Schultz-Pedersen) - Change: MakeButton() now chains new buttons to the top of the button list; this means that in case of overlapping buttons the last created button will be triggered first (requested by Fabio Falcucci) - New: Added "OnMouseDown", "OnMouseUp", "OnRightMouseDown", "OnRightMouseUp" event handler for InstallEventHandler() (requested by Lazar Zoltan) - Fix: Some font bug fixes and tweaks for floating point inaccuracies - Fix: TextExtent() did not return the correct metrics - Fix [Amiga]: Crash when starting a Hollywood script/executable that contained no tooltypes from Workbench (reported by Lazar Zoltan) - Fix: When trying to save an executable to a non-existent place, the temporary input applet file was closed twice which led to a program crash - Fix [Win32/Mac]: Amiga bitmap fonts of type TFCH_ID (using a TFontContents instead of FontContents) could not be loaded (reported by Dirk Riegler) - Fix: ReplaceStr() did not work in all cases (reported by Paul E. Bloedel) - Fix: Crash when specifying huge coordinates for PICXPOS/PICYPOS - Fix: Execute() crashed when used to start a program without any arguments - Fix: Second return value for Val() was wrong in some cases - Fix: Hollywood generated executables with a space in their file name could not be started from Workbench - Fix: Global table _G is now accessible from the script language as it should be (reported by Dwayne L. Jarvis) - Change [Mac]: Mac OS executables created by Hollywood will now use the location of the application bundle as the active directory on startup; previously, the program directory inside the application bundle (i.e. xxx.app/Contents/MacOS) was used as the active directory on startup which caused some confusion - Fix: Exists() works with directories again now (reported by Paul E. Bloedel) - New: LINKFILES argument allows you to link all files specified in a separate file to your applet or executable; all Hollywood commands that load files (e.g. LoadBrush(), OpenFile(), OpenMusic() etc) will load these files directly from your applet or executable then; this is an alternative to using the preprocessor commands; you now no longer have to use the preprocessor commands to link your files with your applet/executable - New: #ATTRFONTASCENDER and #ATTRFONTDESCENDER can be used with #DISPLAY to query the current font's ascender and descender information - Change: Removed #TYPEWRITER transition effect; use a sequence of Print() calls if you really need to emulate it :) - Fix [Mac]: Non-ASCII characters in Amiga bitmap fonts work correctly now (MacRoman is mapped to ISO-8859-1) - Change: ".font" suffix is now optional; you can specify it or leave it out - Fix [Mac]: Changed all text routines to use "Mac Roman" text encoding instead of UTF8; non-ASCII characters are now handled correctly and files/directories with non-ASCII characters work too - Fix: ReadLine() also stored carriage return characters ($0d) in the string; this is no longer done; carriage return is ignored by ReadLine() Version 3.0 (26-Jan-08) - Change: Updated Hollywood documentation - Change: Updated catalog descriptions and German translation; added new developer files for doing new translations - Change: Updated the Hollywood GUI and added an interface for the Hollywood command line demonstration - New: CommandLine example demonstrates how to pass arguments to Hollywood (very cool: tooltypes are supported!) - New: AnimPlayer example demonstrates how to use the new animation API of Hollywood3 - New: Added a Hollywood 3 Intro example which was inspired by the Lotus 3 intro - New: Added four new cracktros supplied by Mr. X of Barracuda; I find them really impressive and they surely show what you can do with Hollywood. Mr. X has ported the cracktros of Steel Empire, Dynablaster, Turrican 2, Turrican 3. Big thanks mate! - Fix: Conversion from C double to C ULONG was not handled correctly for negative doubles under AmigaOS3 because of weird casting behaviour of SAS/C; a work-around is now used (this fix affects the bit-wise operators and some math commands) - Fix: The automatic full screen mode selector should no longer select modes that are not available - Fix: HAM6 and HAM8 animations are now handled correctly - New: GetAnimFrame() command allows you to copy an anim frame from an opened anim into a brush; scaling and disk anims supported - Change: The third argument of OpenFile() defaults to #MODE_READ now; this is a vanity API break; I think that it makes the most sense to have this function default to read-only - New: FileLength() returns the current length of an open file; this length is dynamic because the file is open and write operations could follow - Fix: Internal cursor was not adapted correctly on write operations in the dos library; could lead to pseudo errors in Seek() - New: BinStr() accepts an optional argument now which specifies how many bits it shall take into account (can be #BYTE, #SHORT, or #INTEGER) - New: Cast() function allows you to cast a value to specific type; this is very useful for signing and unsigning values - New: Rol() and Ror() can be used to perform a bit rotation; operator length can be specified (#BYTE, #SHORT, or #INTEGER) - New: Sar() performs an arithmetic right shift (the most significant bit is used for padding) - New: GetProgramInfo() returns information about the program currently running in Hollywood; you can obtain information about the program type (script, applet, program) and the file name of the program - New: GetCommandLine() allows you to retrieve all arguments from the command line which have not been eaten by Hollywood; this is a very flexible function as it also parses tooltypes when a script/applet/program is launched via Workbench; on Mac OS it parses "CFBundleExecutableArgs" entry if Hollywood is started via Finder - New: Pressing the command key and return will switch between full screen and window mode; this is currently only supported by the AmigaOS version; to disable this feature set the NOMODESWITCH argument or the "NoModeSwitch" in the @DISPLAY preprocessor command - New: HIDEPOINTER argument can be used to have the mouse pointer automatically hidden when Hollywood goes into full screen or fake full screen mode; you can also specify HidePointer in the @DISPLAY preprocessor command - New: RemoveLayerFX() command added; why didn't I implement this earlier? Previously, one had to use HideLayerFX() and then RemoveLayer() - New: FileRequest() and PathRequest() accept additional arguments now that allow you to specify the initial path and file state of the requesters (requested by Lazar Zoltan) - Fix: Last path and file were not remembered correctly in FileRequest() function (Hollywood 2.5 only; prior versions remembered it correctly) - Change: PlayAnim() speed is now relative to the time it takes to load and display a frame; if you specify 10 ticks as the speed and it takes 7 ticks to load and display the frame, Hollywood will only delay execution for 3 ticks - New: MorphOS and AROS versions now use Hollywood's stdlib anim driver because they don't have an animation.datatype yet (and probably never will because the animation.datatype's design is quite awkward) - New: IFF 8SVX, IFF 16SV and RIFF WAVE is now supported by LoadSample() on Amiga builds independent of the datatypes system; this is because sound.datatype is a real pain; sound.datatype in MorphOS 1.4 seems to be broken, in OS4 it doesn't work with 16 bit sounds and OS3 often uses experimental replacements; thus, these popular sound formats can now be loaded independent of the sound.datatype - New: Sound part on the Amiga side is now adapted to Hollywood's stdlib and uses the same design as the Win32 and Mac OS builds - New: The OS4, MorphOS, and AROS builds use a different Protracker replayer now which does not rely on AHI's PlayerFunc interrupt any more; this code is a little bit slower (that's why it is not used on OS3), but much cleaner and reliable; thus all the trouble with lowlevel.library under OS4 is a thing of the past now - New: The MorphOS build now supports the non-Amiga keys on the PC-style keyboards now (e.g. F11, F12, Page down, Page up...); currently not possible under OS4 and AROS because we currently don't get IDCMP_RAWKEY for these keys - Fix: Some animations were accidentally loaded without the last two frames (reported by Lazar Zoltan) - New: "FromDisk" argument is now also supported for @ANIM preprocessor command - New: Because the AmigaOS API does not allow for a minimize/collapse gadget in the window's border (like on Mac OS X or Windows), Hollywood installs a hotkey which allows you to do that; just press left command (or right) and 'h' and the Hollywood window will be minimized; this behaviour can be suppressed by using the NOHIDE argument - New: Hollywood opens as a commodity now; this means you can show and hide it from Exchange (this will post the HideWindow & ShowWindow events) and you can also kill it using Exchange; the name displayed in Exchange's list is taken from @APPTITLE; if this is not specified, the initial display title will be used; the title text displayed in Exchange is taken from @APPVERSION; the description displayed in Exchange is taken from @APPDESCRIPTION; the Exchange Show/Hide feature can be suppressed by using the NOHIDE argument - Fix: StringRequest() with type #NUMERICAL was horribly broken (thanks to Juan Carlos Herran Martin for the bug report) - Change: SetPanning() accepts the special coordinate constants #LEFT, #CENTER, and #RIGHT now; the old (& undocumented) constants #PANLEFT, #PANRIGHT and #PANCENTER were removed - Change: FileRequest() uses a new format for the filter pattern now; just pass a string with all acceptable extensions separated by | to the function, e.g. "mp3|wav|8svx|16sv|iff|aiff" etc.; the old Amiga style pattern is still supported on Amiga compatibles, but the pattern must start with a "#" character; to display all files, specify either an empty string, an "*" or "#?" - New: GetTempFileName() returns a file name that can be used as a temporary file; this is important for multi-platform scripts because each platform stores its temp files in different locations (e.g. "T:" on Amiga compatibles) - Fix: ReplaceStr() did only replace the first occurrence of the search string - New: GetAttribute() supports type #CLIPREGION now; you can query the attributes #ATTRXPOS, #ATTRYPOS, #ATTRWIDTH, #ATTRHEIGHT using this type (requested by Kai Stegemann) - New: SetFPSLimit() and GetFPSLimit() are back but you normally should not find any reason to use them; they do not globally restrict the drawing fps but they only affect certain commands which call VWait() to restrict drawing speed; these commands are: PlayAnim(), MoveBrush() etc, DisplayTransitionFX() etc, Flip() and of course VWait() itself; by default, the FPS will be set to the monitor's refresh rate; thus, the commands listed before will run at different speeds with different refresh rates; if you want a constant speed, you can use SetFPSLimit(), but normally it is not necessary - Fix: Using PlayMusic() on a paused Protracker module did not play the Protracker module right from the start but resumed playback from the paused position - Fix: "Time" field of the PlaySample() argument table was handled incorrectly if used together with a custom pitch - Fix: #ATTRDURATION for #SAMPLE returned wrong time if used after a call to SetPitch() - New: The Mac OS X version of the HollywoodPlayer will look for command line arguments in the CFBundleExecutableArgs key of the Info.plist property list inside the generated application bundle if started from Finder; it you launch Hollywood applications from the Terminal, arguments will be taken from the command line instead - New: Mode argument of @DISPLAY preprocessor command accepts "FakeFullScreen" and "OwnScreen" types now, too; additionally, the @DISPLAY preprocessor command also recognizes the "ScrWidth," "ScrHeight," and "ScrDepth" tags (they are only used when display mode is set to "OwnScreen") - New: FAKEFULLSCREEN argument added; this is a convenience argument which configures Hollywood to open on the desktop, but make it look like it was a full screen mode by setting backfill to black and using a fixed borderless window - New: OWNSCREEN, SCRWIDTH and SCRHEIGHT arguments can be specified to make Hollywood open on its own screen; the advantage of the OWNSCREEN argument over the FULLSCREEN argument is that OWNSCREEN does not set any further flags; you still have full control over all the additional window settings like BORDERLESS, FIXED, BACKFILL etc.; SCRWIDTH and SCRHEIGHT can be used to specify the dimensions of the screen; if not specified, Hollywood will try to use the best fitting mode; if you specify 0 for SCRWIDTH or SCRHEIGHT, the dimensions of the desktop are used for the new screen; finally, you can use the DEPTH argument to specify the desired depth for the new screen; if DEPTH is not specified, the desktop's depth is used - Change: If Hollywood is started without arguments, it will automatically open in windowed mode now; previously it opened in full screen mode if started without arguments - Change: Data is now streamed directly from the applet/executable instead of written to a temporary file; only in the Amiga built it is sometimes still necessary to write the data to a temporary file because some functions of the AmigaOS API don't allow custom file functions (e.g. datatypes.library) - New: Added NOHIDE argument; if you pass this argument to Hollywood, the user won't be able to minimize the display (Hollywood will disable the minimize button, but you can still minimize the display by calling HideWindow()) - New: Added event handlers "HideWindow" and "ShowWindow"; they will be sent to your script when the user minimizes the window (or expands it again); in order to have those events sent to your script, you need to install a listener via the command InstallEventHandler() - New: Added commands HideDisplay() and ShowDisplay() which allow you to show and hide the Hollywood display; the script execution will continue in hidden mode, but there will be no more gfx output - New: USEQUARTZ console argument allows you to force gfx output using Quartz 2D; by default, QuickDraw is used because it is much faster on my system than Quartz; this argument only effects the Mac OS version of Hollywood - New: GetVersion() allows you to retrieve information about the Hollywood version in use; this is especially useful to determine on which platform your script is running - New: GetFileAttributes() and SetFileAttributes() can be used to get/set several file attributes including file dates, comments, and flags (e.g. permissions etc.); some differences between the supported platforms apply; please see the documentation for information on what is supported on which platform; can also be used with directories - New: #ATTRHOSTWIDTH and #ATTRHOSTHEIGHT return the dimensions of the host desktop screen on which the Hollywood display is opened (use it with #DISPLAY as the super class) - New: #ATTRBORDERLEFT, #ATTRBORDERTOP, #ATTRBORDERRIGHT, #ATTRBORDERBOTTOM can be queried for #DISPLAY; they will return the left, top, right, or bottom sizes of the display border (if there is any); this is useful for advanced users who need to obtain that info for example to position the cursor using MovePointer() or for moving the display using MoveDisplay() - New: #ATTRXPOS and #ATTRYPOS can also be used with #DISPLAY now; queries the position of the display on the desktop - Fix: Memory leak in ARexx event handler (reported by Richard de Rivaz) - Fix: Under very rare circumstances, a wrong button event could be triggered (reported by Lazar Zoltan) - Fix: #STRUDEL effect could cause a complete system crash under certain circumstances (reported by Rafal Chyla) - New: Hollywood has landed on two new platforms: Win32 and Mac OS X are now supported! This is made possible by the new OS abstracted design of Hollywood. The kernel of Hollywood has been fully OS abstracted since version 2.5. Supporting new platforms is now only a matter of writing a driver for it. No changes to the Hollywood kernel are necessary! Version 2.5 R1 (19-Mar-07) - Change: Hollywood uses the charset of the system now under AmigaOS4; so you can also create text objects with Polish characters etc. (reported by Rafal Chyla) - Fix: CTRL-C in the CLI window spawning the Hollywood task is now handled correctly (reported by Lazar Zoltan) - Fix: Increased alpha map allocation for thick anti-aliased lines by 1 so that OpenCV has enough space to draw (memo: it subtracts 5 from the alpha map dimensions so we need to allocate at least 6 pixels) - Fix: Position of #DISPLAY and #ANIMDISK constants was in the wrong order which led to compatibility problems with applets that have been compiled with Hollywood 2.0 - Fix: The Hollywood Player did not respect the tooltype settings in the icon (reported by Marco Fogli) - Fix: MoveDisplay() did not work correctly after ChangeDisplaySize() (reported by Paul Bloedel); +further fixes, Hollywood does no longer access the window structure directly to avoid these problems - Fix: If SetTimeout() and SetInterval() needed to free an old timer before starting the new one a wrong pointer was used which led to a system crash (reported by Paul Bloedel) - Change: Added some more true type fonts to the distribution (AmigaOS3 and WarpOS only) Version 2.5 (08-Mar-07) - Change: Updated Hollywood documentation - Change: Updated catalog descriptions and German translation; added new developer files for doing new translations - Change: Updated the Hollywood GUI and added a remote control for the Hollywood ARexx demonstration - New: Added Text example script which demonstrates the features of the new text engine in a resizable window - New: Added FormsDemo example script which demonstrates the completely new drawing library of Hollywood 2.5 - Change: FontsDemo uses a system true type font now instead of a custom true type font loaded via ttengine.library (ttengine is no longer supported as of Hollywood 2.5!) - Change: PolygonTest example now also demonstrates the new Hollywood 2.5 form styles (#ANTIALIAS, #SHADOW, #EDGE); SizeWindow capability removed; would be too complicated because the border can get quite huge with odd window sizes - Change: The Zool and Pang cracktros will stream the sound now; this is possible now because OpenMusic() can stream sample formats - Change: The HollyAmp example script supports the new music streaming formats of Hollywood 2.5 now (IFF 8SVX, IFF 16SV, RIFF WAVE); also fixed a bug in HollyAmp - Fix: Lens.iff from the Lens example was a GIF file in reality; I have now converted it to IFF - Fix: BoingAttack example used a corrupt Protracker module; the replayer did not have any problem with it but it was still corrupt - Change: Adapted ImageLab for Hollywood 2.5 - New: Added a groovy new example that communicates with the Hollywood GUI to demonstrate the ARexx library of Hollywood 2.5! - Fix: Not all libraries were shown in the "system information" dialog in the GUI - New: Attributes #ATTRXPOS, #ATTRYPOS and #ATTRONSCREEN can now be queried for type #SPRITE (requested by Kai Stegemann) - Fix: Wrong error message if sprite could not be found by GetAttribute() - Fix: Functions which also accepted percent values as arguments did not handle numbers specified as strings correctly - New: FlushFile() can be used to flush all pending buffers; this is needed if you switch between buffered/unbuffered IO on the same file; for advanced users - New: SetIOMode() allows you to switch between buffered and unbuffered IO; by default all functions of the DOS library will use buffered IO and that's okay for most uses; some advanced users, however, might prefer to use unbuffered IO which can be used to send data directly to DOS filehandles; for example if you open a console window with OpenFile() or you access the parallel port through the file system, unbuffered IO is clearly a better choice because it passes all data directly to the file system; all DOS functions will respect the setting made with SetIOMode() - New: ConvertToBrush() supports type #LAYER now - Fix: If there were overlapping buttons on the BGPic, hover was not handled correctly (reported by Simon Neumann) - Fix: Several fixes so that Hollywood works with the final version of OS4 - New: Polygon() now uses double precision for the vertices; they're rounded to integer right before rendering the pixel data - Change: Hollywood.sys uses a new modular format now; the old format was still a relic from Hollywood 1.0 and not really suitable for all the different changes that have been made in the meantime - Fix: FreeSprite(0) freed all sprites on the display (reported by Nathan Hesterman); please note that you should not use IDs < 1 for your objects; the ID system needs to be reworked in order to allow that - Fix: Hollywood 1.x style ONKEYDOWN events were not emulated correctly in Hollywod 2.0 - Change: Removed the second compatibility hack for Hollywood Designer 1.01; this hack is not required by Designer 2.0 either - New: Implemented a brand-new gfx driver for the AROS version; the Hollywood OS abstraction layer makes it possible; the standard gfx driver relied heavily on locking bitmaps which is not possible under every hosted AROS version and thus caused a HUGE slowdown; the new gfx driver for AROS does not need to lock bitmaps any more and hence is so much faster than the old one. This is as fast as it gets. Run Hollywood on AROS on a modern PC and enjoy the lightning speed! - Change: Usage of a table as the sixth argument to Polygon() is now deprecated; the 6th argument is now reserved as a rotation argument; the table synopsis from Hollywood 2.0 is still supported for compatibility's sake - New: Unified object types #ANIM and #ANIMDISK; to play an animation from disk just use LoadAnim() now with the new table argument "FromDisk" set to TRUE; you can use all the functions from the anim library with "FromDisk" anims then; the functions for anim layers with also work; the command PlayAnimDisk() still works but does nothing else than calling LoadAnim(), PlayAnim() and FreeAnim() - Fix: Round() did not work correctly on negative numbers - Fix: Wrong error message when changing the display size to a size larger than the host screen - New: RotateBrush() can also do anti-aliased rotations now; use the fifth optional argument to enable anti-aliased rotation mode - New: RotateBrush() can also zoom brushes; you can do a rotzoom by using the new two optional arguments factorx & factory; these are scaling factors which specify to much extent the brush shall be scaled - New: ScaleBrush(), ScaleAnim(), ScaleBGPic(), ScaleSprite() and ChangeDisplaySize() all accept an optional argument now which specifies whether or not the scaled gfx data shall be anti-aliased; alpha channel anti-aliasing supported for brushes and sprites - Fix: Improved scaling algorithm (old one had some issues; reported by Lazar Zoltan) - Fix: ExitOnError(FALSE) did not work correctly in user callback functions; Hollywood did not throw any errors but left the callback function - New: Added type #LAYERBUTTON to the MakeButton() function; this new type allows you to define layers as buttons; the fourth argument specifies whether or not the collision detection for the button shall be pixel-exact; this is useful for creating irregular shaped buttons now); the fifth argument specifies whether the button shall be hidden if the layer is hidden; the sixth argument is a function table with the same entries as in #SIMPLEBUTTON; if you free a layer, its button will also be killed - Fix: Freeing buttons or the current bgpic in OnMouseOver and OnMouseOut user functions could lead to a crash - New: All gfx primitives can now also be drawn using rotation; the following commands accept an optional argument now which specifies the rotation angle in degrees: Arc(), Box(), Ellipse(), Polygon(); the Circle() command does not support rotation because circles look the same with every rotation angle; this argument defaults to 0 which means no rotation - New: Arc() accepts a new parameter now which allows you to specify whether the arc shall be drawn in clockwise or anti-clockwise direction (defaults to TRUE which means clockwise drawing) - Change: HUNK_DEBUG information is no longer included the in the hunk header for 68k/WarpOS executables; this saves memory because the OS loader won't load the data attached to the executable into memory now (thanks to Gunter Nikl for the hint!) - Fix: Using the THEN identifier after ELSEIF resulted in a crash of Hollywood; now the parser reports the error to the user instead of freezing the system (reported by Christoph Gutjahr) - Fix: Registering constants during parsing could invoke the garbage collector which could lead to random crashes at exit (reported by Lazar Zoltan) - Change: Polygon() also accepts negative coordinates in the vertices array now; also slightly changed the alignment of rotated polygons - Fix: Polygon was not closed correctly if the start coordinates were not explicitly specified as the end coordinates - Fix: RemoveItem() did not work correctly when trying to remove the last remaining element of a table (reported by Nathan Hesterman) - New: SetFormStyle() allows you to configure the style for the drawing primitives: The command accepts the styles #SHADOW, #EDGE, and #ANTIALIAS; the following commands support all three styles: Arc(), Box(), Circle(), Ellipse(), Polygon(); the Line() command only supports #ANTIALIAS style. #EDGE and #SHADOW are not supported for lines; usage of this command is similar to SetFontStyle(); the edge and shadow colors can also contain an inverted alpha value; anti-aliasing is fully implemented here including support for all fill styles (#FILLNONE, #FILLCOLOR, #FILLGRADIENT, #FILLTEXTURE); the implementation of SetFormStyle() required an almost complete rewrite of the drawing library; the new version is not nearly as fast as the old version of 2.0 was, but it is much more flexible now and the anti-aliased routines look great for line based polygons; the round forms are not perfect yet but still good - Fix: Line() function did not accept special coordinate constants as start/end points - New: The Line() function accepts a new argument now which specifies the line thickness - New: Alpha drawing now also supported for #FILLGRADIENT and #FILLTEXTURE; just pass the alpha value in the color argument of the functions of the drawing library (the rest of the color argument is ignored on #FILLGRADIENT or #FILLTEXTURE) - Change: When you draw gfx primitives with alpha blending and layers are enabled, the specified alpha value will no longer be used as the new layer's transparency; you will get a new layer that has no transparency setting - Change: Plot() can no longer be used with layers enabled; plot layers just don't make sense; if you really need a pixel layer, use Box() with width/height = 1 - Fix: Plot() did not respect sprites at all - Fix: Plot() and ReadPixel() did not work correctly if a custom shaped clip region on a position different than 0:0 was active - New: TextOut() accepts a new optional argument which you can use to output word-wrapped text: just pass a width parameter in argument 5 and the text printed by TextOut() will not exceed this width; defaults to 0 which means no width restriction - New: TextOut() accepts a new optional argument now which specifies the text alignment; this change breaks with the old API; in previous versions the alignment was automatically set to #CENTER if x was #CENTER and to #RIGHT if x was #RIGHT; this is no longer supported now; you have to use the new optional argument now; this argument defaults to #LEFT - Fix: Evaluation of constant expressions in table arguments of preprocessor commands was horribly broken (reported by Nathan Hesterman) - Change: Removed a compatibility hack for Hollywood Designer in PlayAnim() and PlayAnimDisk(). With the latest version of Designer, this hack is no longer necessary. - New: NextFrame() and InsertLayer() can now also be used with layers of type #ANIMDISK. This allows you to use huge animations that are played from this as anim layers, too. Quite useful. For AddMove() there is a new type called #NEXTFRAME2 which takes a layer id as source, thus allowing you to address both #ANIM and #ANIMDISK layers (whereas #NEXTFRAME only allows you to address #ANIM layers). #ATTRCURFRAME and #ATTRNUMFRAMES can also be used on layers of type #ANIMDISK now. [addendum Feb-07: #ANIMDISK now completely removed; to play anims from disk just use LoadAnim() with the new "FromDisk" tag] - New: Animations that use multiple palettes are now handled correctly - Change: The IFF ANIM loader now checks the DPAN chunk first to find out the number of frames in the animation - Fix: If OnSampleLoop or OnSampleEnd was set up before Hollywood opened ahi.device, then those event handlers were not installed at all - Fix: Freeing a sprite during preprocessor loading resulted in a crash - Fix: The "Time" argument of the PlaySample() command did not work correctly if the following two conditions were present: 1) time shorter than the sample duration & 2) single sample frame size greater than 1 byte (e.g. stereo or 16-bit samples) - New: Peek() accepts an optional argument now, which can be used to peek a string with of a fixed length instead of auto-termination - Fix: When peeking a string using Peek(), the string returned had one character too many - Fix: UnrightStr() and Poke() did not handle strings with null character correctly - Fix: #BLEND, #FADE, #VFLOWLEFT, #VFLOWRIGHT, #HFLOWTOP, #HFLOWBOTTOM, #WALLPAPERLEFT, #WALLPAPERTOP, #ROLLLEFT, #ROLLTOP, #PIXELZOOM1, #PIXELZOOM2 did not work correctly on objects with alpha channel - Fix: Wrong behaviour of SetMusicVolume() when a stream was playing and SetMusicVolume() was used to modify the volume of a Protracker module - Fix: When SetMusicVolume() was used on a playing music, the new volume was applied but not memorized; thus, after ResumeMusic() the music would play in the old volume - Fix: MakeButton() did not accept special coordinate constants (reported by Kai Stegemann) - Fix: OpenMusic() could fail to open files if the path specification was relative and the current directory was changed - New: All music files declared using the @MUSIC preprocessor command will now be linked to the applet; even MP3 streams can be included in your executables this way; if you do not want to have them linked, use the Link=False option - New: OpenMusic() can stream IFF 8SVX, IFF 16SV, and RIFF WAVE sound files now. Sample data can be in 8 or 16 bit, mono or stereo; compression is not supported yet. Because there is no datatype API for streaming yet, Hollywood employs custom code to do it - New: PlayMusic() can loop the music now automatically; you can tell the function how many times the music shall be played through the second argument; use 0 for infinite looping; does currently not work with Protracker modules - New: ConvertToBrush() allows you to convert various objects to brushes. Sprites are supported here too. The Hollywood 1.x function GetBrushLink() simply calls ConvertToBrush() now, too. Brush link support was already removed in version 2.0. - New: SaveBrush() and SaveSnapshot() can save PNG files now, too. This is especially useful for SaveBrush() because, if the brush has an alpha channel, a PNG with alpha transparency will be written. The PNG datatypes of the various Amiga systems do not support file writing yet, so you will need pngalpha.library for this feature. - New: ARexx interface. Many people have asked me to add ARexx support to Hollywood so here it is. You can now address ARexx by using the commands SendRexxCommand() and RunRexxScript() - remember that the first line of an ARexx script must always be a comment! Furthermore, you can also receive messages from other applications by installing your own ARexx port. You can do this with CreateRexxPort(). After you have created a rexx port, you have to install the new "OnARexx" event handler using the InstallEventHandler() function. Every time an ARexx command is received, this handler will be called then with "action" initialized to "OnARexx". You will also receive the command in the "command" field and the fields "args" and "argc". "args" is a string containing "argc" arguments pre-parsed by Hollywood and delimited by null characters; use SplitStr() to convert them to single strings; you may also access the unparsed arguments; they will be stored in the "rawargs" field - Fix: When many timeouts returned at the same time, some were usually lost because Hollywood was limited to 16 timeouts per vm cycle; this limit has been removed now so there's virtually no limit of timeouts and every timeout function should be executed (reported by Alexander Weber) - Change: Hollywood scheduler does no longer run as its own task; gives about 10% more performance on expensive scripts - Change: CheckEvent() removed. Please use WaitEvent() instead. - New: You can also copy raw alpha channel data with Hollywood now. To achieve this special mode, set SetAlphaIntensity() to the special mode #VANILLACOPY; this mode will do a vanilla copy of the alpha channel data; if you call a drawing command which does not contain any alpha data, nothing will be written to the brush's alpha channel - Fix: Possible memory access fault in CopyFile() - Fix: When SelectXXX() was active, and a window resize occurred, and a double buffer was set up, Hollywood forgot to scale the double buffer - Change: #TYPEWRITER effect looks much better now due to the new text engine. Expect some cool new text effects soon. - New: Text engine completely rewritten. Now much better than the old one! You can now change font styles on-the-fly using format tags. The following format tags are currently implemented: [b], [u], [i], [color], [edge], [shadow]. Edge and shadow support for anti-aliased fonts is now fully implemented and looks great. Edge and shadow transparency on anti-alias fonts also supported. This is powerful. Use it wisely. - New: CreateTextObject() accepts an additional argument now that allows you to give the object a specified width; the text will be wordwrapped then - New: #ATTRCURSORX and #ATTRCURSORY can be used to find out the current cursor position (#DISPLAY is the super class of these attributes) - New: TextExtent() allows you to retrieve detailed information about the boundaries of a string; remember that TextWidth() only returns the cursor advancement of a string - New: Italic soft style for anti-aliased fonts now supported! - New: Just like the functions of the draw library, the text library supports transparent text now, too. Just specify an inverted alpha value before the color! (0 = solid, 128 = 50% transparency, 255 = 100% transparency). You could also use this feature to create an outline text font style: To do this set the transparency of the font color to full ($ff) and use the new edge style. Hollywood will only draw the text edges then, resulting in nice outlined text. - New: Introducing new soft styles for text: #SHADOW and #EDGE. You can configure the shadow color, size and direction as well as the edge color and size. Use SetFontStyle() to install them. - Change: ttengine.library no longer supported. The text engine is about to undergo a major change and I'm concentrating now on the bullet interface (ft2.library on OS4, freetype2.library on MOS/AROS). For AmigaOS 3.x there's a back-port of freetype2.library available, or you can use ttf.library but the latter does not support anti-aliased glyph output. - Fix: Plot() did not handle alpha value correctly - Fix: When drawing an alpha-blended rectangle with #FILLNONE, the four edges were alpha-blended twice - Fix: Cursor position will be reset to 0:0 on a display size change and to the top-left of a clip region on SetClipRegion() - Fix: When SelectXXX() was active and a display size occurred, the margin and cursor settings were not adapted correctly - Fix: luaV_tostring() always returned a random value instead of 1 - Fix: Hollywood could crash the system on window refresh when SelectMask() or SelectAlphaChannel() were active - Fix: WriteString() was broken - New: Hollywood is completely OS abstracted now; all OS dependent functions have been abstracted from the main source code so that it is possible to write Hollywood backends for other platforms now Version 2.0 R1 (10-Jun-06) - Fix: On some OS4 systems Protracker modules that tried to change the tempo could crash (reported by Rev. Bloedel) - Fix: Hollywood tried to write to const* memory several times; this causes a crash with the latest beta OS4 kernel which protects those areas (reported by Tony Wyatt) - only the AmigaOS4 interpreter and player binaries got an update; the rest are kept at revision 0 from 30-Dec-05 Version 2.0: (30-Dec-05) - Change: Updated Hollywood documentation; now twice as big! - Change: Updated catalog descriptions and German translation - Change: Removed Settings tool; no longer supported; you can use @DISPLAY with Mode="Ask" instead - Change: OnSampleEnd event is only sent when the sample has finished playing; it is not sent when StopSample() was called - New: Added a funky new Welcome 2.0 script! - New: Added many new examples: AlphaChannel, PacMan, ClipRegions, FloodFill, BoingNG, Melt, HollyAmp, Collision, Aladdin cracktro (original by Prodigy), Zool ECS cracktro (original by Melon), Pang! cracktro (original by Horizon), Lemmings cracktro (original by Skid Row), Badger Badger Badger; the cracktros and the Badger dance were contributed by Mr.X of Barracuda; thanks mate! - Change: Vectorballs example now bears the name "AnimationTechniques"; I also removed the BGPic Vectorballs script and added a version that uses sprites - Change: Renamed RainbowCreator example to Gradients - Change: removed MoveAnim, WinFileCopy, Scroller and WBFadeOut examples - Change: APPTITLE, APPVERSION, APPCOPYRIGHT, APPAUTHOR, APPDESCRIPTION arguments (only present in internal 2.0 betas) are now implemented as preprocessor commands, i.e. @APPTITLE, @APPVERSION and son. These preprocessor commands allow you to store some information about your program in your applet/executable - Change: Removed STAYACTIVE argument/tooltype; no longer required; the background window will take care of the matter automatically - New: Optimized loading for graphics specified in @SPRITE and @BRUSH. Hollywood will cache the image now if it is to be loaded multiple times so that loading goes much faster now - Change: LoadSprite() uses a table for the optional arguments now (just like LoadBrush() does) - New: TrimStr() can be used to strip leading or trailing characters from a string - Change: All functions of the string library work correctly now with strings that have embedded zeros ("\0"); for instance, StrLen("\0\0\0\0") returns 4 now and you can also do wild stuff like SplitStr("Hello\0World\0Hello\0Hollywood", "\0") - New: #ATTRTYPE and #ATTRPITCH can be used with MPEG audio files now, too - New: #ATTRBITRATE can be used to find out the bitrate of an MPEG audio file; note that if the file is encoded using a VBR, you will get the bitrate of the current frame - New: OnMusicEnd event handler is triggered when a music has reached the end or is stopped! Currently works only with MPEG audio files. - New: Completely rewrote the Hollywood GUI! Now has a showcase for all examples and some other cool features! - New: Pairs() and IPairs() return common iterators for the generic for loop - New: NextItem() allows you to traverse a table; be careful with the return value which is Nil when the traversal is done! You cannot use "While r <> Nil" because that would also terminate the loop on r:=0. Use "While GetType(r) <> #NIL" instead which is the only reliable way to check a variable against Nil in Hollywood because in expressions, Hollywood regards Nil as 0! Don't expect that NextItem() returns the items in the order you initialized them! - Change: Different Protracker timer is now used on OS4. This had to be changed because Davy Wentzler's sound drivers are buggy and he refuses to fix it. - New: If double buffering is active and the size of the display is changed, the double buffer will automatically draw its graphics scaled so that it fits the display - New: The commands of the drawing library (graphics primitives) can draw alpha blended graphics now, too. Simply specify an alpha value in the highest 8 bits of the RGB color, e.g. $80ffff00 will draw yellow with 50% alpha transparency (50% = 128 = $80). Note that the alpha value is inverted as in SetLayerTransparency(): 0 means no transparency, 255 means full transparency. Normally it is just the other way round (cf. SelectAlphaChannel). Alpha drawing is highly optimized and supported by Polygon(), Arc(), Ellipse(), Circle(), Box(), Line() and Plot(). Use ARGB() to easily combine a RGB color with alpha, e.g. ARGB(128, #AQUA). - New: ARGB() combines a RGB color with an alpha value - New: Every preprocessor command which preloads files accepts an optional argument "Link" now which specifies if the corresponding file shall be linked into an applet/executable when a script is compiled; NODATALINK is obsolete now (was only present in internal 2.0 betas); link defaults to TRUE, so you only have to set it when you do not want a certain file to be linked into the applet/executable - New: Many of the command line options can also be specified in your script now. For instance, you can now specify in your script whether it shall run in full screen or windowed mode. The disadvantage here is, that if you hard-code the settings in your script, it is not possible to change those settings from the command line. All arguments have to be specified in the @DISPLAY preprocessor command. Currently supported are: Mode (can be "Windowed", "FullScreen" or "Ask"), Borderless, Sizeable, Fixed, HideTitleBar, Backfill. Backfill expects an other table which can contain the following arguments: Type ("Color", "Gradient", "Texture" or "Picture"), X, Y, Color, StartColor, EndColor, Brush. FIXSETTINGS is now obsolete (was only present in internal 2.0 betas) - Change: Backfill mode RAINBOW is now called GRADIENT; RAINBOW is still accepted, though - New: @FILE preprocessor command allows you to preload files for read-only access. The cool feature here is that files specified in @FILE will also be linked to your applets/executables and you can work with them as if they were normal files - New: Polygon(), Circle(), Ellipse() and Arc() are much faster now in many cases - New: WaitTimer() call waits until a timer has reached the specified time, then resets it and continues with the script; useful in loops that must not run faster than a specified limit! - New: RemoveSprites() removes all sprites that are on the display; if the optional argument "keep" is set to true, the sprites will be removed internally but not from the display. In case keep=True, they will remain on the display but as normal gfx, not as sprites. - New: ToNumber(). Basically does the same as Val() but takes an additional base argument which can be used to convert strings to numbers with bases 2-36 - Change: LoadBrush() accepts a table as argument 3 now which can be used to specify the transparent color, whether an alpha channel shall be loaded, global alpha setting and brush cropping; everything can also be specified in the new @BRUSH preprocessor command - Change: Compiler recognizes identical files and links them in the applet/executable only once - Change: FramesPerRow arguments in CreateSprite(), @SPRITE and CreateAnim() are optional now; number of frames used as default - Change: Transparent windows on OS3 do not get a clip region installed any longer because that would prevent them from using layers - New: Polygon() accepts an optional table argument now which can be used to scale or rotate the polygon before it is drawn - New: ChangeInterval() can be used to change the frequency of a running interval! - New: Error() allows you to make Hollywood quit with a custom error message - New: GCInfo() and CollectGarbage() allow control over Hollywood's garbage collector; not necessary normally - New: Print(), NPrint() and DebugPrint() use ToString() now, too - New: ToString() function in Hollywood's system library; if a table is passed to this function, ToString() will look for a __tostring metamethod and call it if present - New: RawEqual(), RawGet() and RawSet() can be used to query a table without invoking a metamethod - New: Metatable support added! Use the functions SetMetaTable() and GetMetaTable() to deal with them. The following metamethods are supported: __index, __newindex, __add (+), __sub (-), __mul (*), __div (/), __divint (\), __mod (%), __lsh (<<), __rsh (>>), __or (|), __and (&), __xor (~), __pow (^), __unm (-), __not (~), __eq (=), __lt (<), __le (<=), __concat (..), __call () - Change: When creating an applet/executable, Hollywood checks if the files are in a supported format before linking them - New: @MUSIC preprocessor command. @MODULE command removed because Protracker modules are only a sub-class of the music class now. Please note that @MUSIC does not link MPEG audio files into applets/executables; those files will always be kept external. Protracker modules, however, are linked to the applet/ executable if specified in @MUSIC (unless NODATALINK is active) - New: #ATTRFORMAT can be used to find out the type of an open music; currently supported: "Protracker" and "MPEG Audio" - Change: Merged Protracker module playback with the new music commands: OpenMusic(), PlayMusic() and so on should now also be used when playing Protracker modules. The old LoadModule(), PlayModule()... functions are still supported for compatibility but are likely to be removed in one of the next versions! - Change: GetSamplePosition() removed (command was only available in internal beta versions); please use #ATTRPOSITION together with #SAMPLE instead - New: #ATTRDURATION and #ATTRPOSITION can be used to find out the duration and position (in milliseconds) of a music - New: Introducing MP3 support! Many people have asked me to implement support for MP3 playback, so here it is. The following functions are implemented: OpenMusic(), CloseMusic(), PlayMusic(), StopMusic(), PauseMusic(), ResumeMusic(), SeekMusic(), SetMusicVolume(), IsMusic(). Currently, you can only open MPEG audio files with OpenMusic(). In the future, I might add support for other formats like ogg vorbis etc. Limitations: Only one music can play at a time & music and Protracker modules cannot be played at the same time. Hollywood uses mpega.library for decoding the MPEG audio files - New: Introducing special functions for double buffered graphics! It is no secret that double buffering with Hollywood could already be achieved by using two brushes and drawing to them using SelectBrush() but the new functions can do this faster and easier! There are just three functions: BeginDoubleBuffer(), EndDoubleBuffer() and Flip(). See the examples and documentation to learn more; restrictions: Double buffering does not work with transparent displays, layers and sprites! Clip regions supported! - New: Box() and Line() can draw their graphics very fast now in most cases; I've added special code for straight-forward drawing that can be used if the following conditions are met: 1) layers are off, 2) there's no custom shaped clipping rectangle, 3) the gfx object does not collide with a sprite, 4) output device is either the main display or a brush or double buffer - Change: CreditsRoll example displays Hollywood Designer credits now - New: Added a small gfx toolbox for the sprite library: CopySprite(), ScaleSprite() and FlipSprite() should be enough to get you started with sprites; if you need more advanced functions, use the brush functions to manipulate the gfx and then use CreateSprite() to convert the brush to a sprite - Change: 3DText uses a sprite now instead of an IFF ANIM; good for systems without a correct datatype, i.e. MorphOS and AROS - New: Attributes #ATTRHASMASK and #ATTRHASALPHA allows you to query sprites and brushes to check if they have a mask or an alpha channel - New: GetAttribute() supports #SPRITE now (attributes: #ATTRWIDTH, #ATTRHEIGHT, #ATTRTRANSPARENTCOLOR, #ATTRNUMFRAMES, #ATTRCURFRAME) - Change: Clip regions don't work together with layers any longer! Layers should only be used for presentations... most applications do better without layers now - Change: Sprites don't work together with layers any longer! - Change: MixBrush() takes alpha channel of the source brush into account now - Change: Mask and alpha channel in a brush are now mutually exclusive, i.e. you cannot have a mask that carries both a mask and an alpha channel; SelectAlphaChannel() will delete a possible mask and SelectMask() a possible alpha channel - New: Introducing a replacement for the so called "keywords": Preprocessor commands! Preprocessor commands are basically the same as the keywords, but they have a different, more flexible syntax. Each command has to be prefixed by an at character (@) and accepts a number of arguments that must be separated by commas (keyword arguments were separated by slashes). The new syntax allows the usage of (constant!) expressions in arguments and also tables can be specified, which is useful for more complex symbols like @SPRITE. The following preprocessor commands are implemented: @BGPIC, @BRUSH, @ANIM, @SAMPLE, @MODULE, @SPRITE, @VERSION (replaces %HOLLYWOOD), @DISPLAY (combines the keywords %TITLE, %DISPLAYPOSITION, %DISPLAYDESKTOP, %DISPLAYCOLOR and %DISPLAYSIZE), @INCLUDE. Preprocessor commands can be placed anywhere in the script but for readability reasons they should be at the beginning of the script. Also, it is strongly advised to use the @VERSION symbol in the first line of your code, so Hollywood can check if the installed Hollywood interpreter can handle this script. All 1.9 keywords are still supported for compatibility reasons of course. Please read the documentation. - Change: %DISPLAYPOSITION, %INCLUDE, %SPRITE keywords removed. Preprocessor commands are coming up! - Fix: Small memory leak in FreeAnim() - New: Collision() can detect collision between sprites (use type #SPRITE) - New: Introducing sprites! Hollywood now has functions for you to work with sprites. Sprites are graphic objects that are always on the front of the display and can easily be moved around. A sprite can only be on the display once. E.g. if you display sprite 1 at 100:100 and then display it again at 200:200, the sprite will be moved from 100:100 to 200:200. Hollywood sprites are implemented completely in software; hence, there are no limits in size, number, whatsoever. Sprites can also have a mask or alpha channel. A sprite can also have multiple frames of animation. This is all perfect for games. Be sure to check out the documentation and examples to see what can be done. Hollywood's sprite library currently offers the following functions: CreateSprite(), DisplaySprite(), FreeSprite(), RemoveSprite(), MoveSprite(), LoadSprite(), %SPRITE keyword - New: Hollywood's window is now of simple refresh type - New: Collision() now also detects collisions between objects that have an alpha channel - Change: Added emulation for GetBrushLink(); the new version will not obtain a link to the brush but copy it; type #LAYER not supported; this is mainly because Designer uses GetBrushLink() - Change: Senso uses Arc() now instead of prepared brushes - Change: SelectMask() and SelectAlphaChannel() create the mask/alpha channel not before the first drawing operation to the brush; e.g. SelectMask(1) EndSelect does not create a mask for brush 1 any longer - New: Function DeleteMask() kills the mask of a brush; this command does basically the same SetBrushTransparency(brush, #NOTRANSPARENCY) - New: DumpLayers() prints info of all layers in the system (private) - Change: Because of the removal of the "quiet" argument, the optional x&y arguments (new in Hollywood 2.0) for ShowLayer() are now on position 2 and 3 for ShowLayer() - Change: Removed optional "quiet" argument in: SetLayerTransparency(), SetLayerTint(), SwapLayers(), RemoveLayer(), ShowLayer(), HideLayer() ---> Designer 1.01 uses HideLayer() with the "quiet" argument --> adaption necessary! e.g. you could use SelectBGPic() with the current bgpic as a workaround. In this way the layer will be hidden but not redrawn... - New: Introducing substitute layers! If you free/modify a brush/anim/etc that is on the display, the gfx data will be saved so that refresh is still possible! - Change: If SelectBGPic() is used on the current background picture, all layers will be inserted in hidden mode; you can bring them to the front with ShowLayer() - Change: SelectBGPic() can only be used with layers on; in internal beta versions of Hollywood 2.0 it was possible to use it with layers off (direct render mode); not possible anymore - Change: Removed BeginRefresh(), EndRefresh() and SetRefreshMode(); these commands were only available in internal beta versions; Sprites are coming up! - Change: Removed GetBrushLink(); this command just made things too complicated! - Change: SetClipRegion() splitted in CreateClipRegion(), SetClipRegion() and FreeClipRegion() - Change: FloodFill() can only be used on a brush now; alpha channel and mask flooding no longer supported; it does not make much sense IMHO; memo: sources for alpha & mask flooding are still available in ppc_support.c in the last smart refresh back-up - Change: Implementation of Cls(): If output mode is BRUSH/ALPHACHANNEL/MASK, the Cls() command will clear the area with the specified color (BRUSH) or alpha intensity or mask mode; if output type is BGPIC or MAINWINDOW, Cls() will remove all layers and refresh objects and will leave an empty bgpic on the display - New: APPTITLE, APPVERSION, APPCOPYRIGHT, APPAUTHOR, APPDESCRIPTION arguments allow you to place some information about your program in your applet/executable. Especially the APPVERSION argument is useful to put version strings in your program, e.g. APPVERSION "$VER: MyProgram 1.0 (12-06-05)". These arguments make only sense when used with COMPILE! [VOID; use @APPTITLE, @APPVERSION... instead] - New: FIXSETTINGS argument allows you to fix the display settings in your applet/executable. For example, if you execute "Hollywood myscript.hws COMPILE ram:myprg.exe FULLSCREEN FIXSETTINGS", then myprg.exe will _always_ be started in fullscreen mode. Even if the user executes "myprg.exe WINDOW", your program will be started in fullscreen mode because you fixed that setting in the executable! Useful. This argument makes only sense when used with COMPILE! [VOID; specify settings in @DISPLAY instead] - New: NODATALINK argument will prevent the compiler from linking all data files specified in the keywords into the applet/executable. This argument is useful if you have different executables for let's say AmigaOS3, AmigaOS4, MorphOS and WarpOS. In this case it would not make much sense to have all data linked into each of the executables. It's much better to keep the data extern in this case! This argument makes only sense when used with COMPILE! [VOID; use the Link argument which all preprocessor commands support now] - New: Introducing Hollywood applets! You can compile your scripts into applets now by using EXETYPE=APPLET. Hollywood applets can be started by Hollywood or the freely available HollywoodPlayer which is a special version of Hollywood that can run applets only! Applets are platform independent, all versions of Hollywood/HollywoodPlayer can run your applets no matter on which platform they were compiled! - New: Keywords can now be anywhere in the script! The %CODE keyword is no longer necessary! However, it is advised that you use the keywords at the beginning of the script (for readability reasons) - New: Hollywood is now also available in a i386 native version for AROS (the Amiga Research Operating System); this closes the circle: Hollywood is now available for all major Amiga compatible operating systems - Change: Using keymap.library instead of console.device now - Fix: FULLSCREEN/BESTFIT did not always choose the best screenmode available - New: StrToArray() converts a string to an array of characters (0 - 255) - Change: Migrated the 68k assembler Protracker replayer in ptahiplay.library to clean, portable C in a 12+ hours coding shift on Christi Himmelfahrt 2005; this means that ptahiplay.library is no longer required by Hollywood! (whoa, finally...) - Change: Senso example plays cool sounds now (made by CreateSample) - New: CreateSample() allows you to create your own samples from raw wavedata - New: Added event handlers OnSampleLoop and OnSampleEnd; these allow you to create scripts that are exactly timed with samples; you can install the handlers by using InstallEventHandler(); be careful with OnSampleLoop in connection with very short, looped samples; they can easily block your program - Change: PlaySample() implementation changed; playback is now started immediately without the 50-100 milliseconds delay; additionally, you can start up to 4 samples at the same time by adding them as optional arguments; playback will be exactly synchronized then; read the doc - Change: Puzzle example shows a clock now; no problem with SetInterval() - New: PadNum() converts a number to string and pads it with leading zeros - Change: Default mode of GetTimer() is always milliseconds now; optional argument is ignored; this is an API break but noone used #SECONDS for GetTimer() anyway so this is harmless - Change: Adapted all examples to the new Hollywood 2.0 design; they would have worked without the rewrite too but the examples shall be role models for good Hollywood programming and therefore I decided to rewrite them completely to show you how to program Hollywood correctly - Change: Welcome example shows a spinning Commodore logo now - Change: WavyLogo example has now additional buttons for selecting a FPS rate; this demonstrates SetInterval() with different rates; additionally, the actual FPS are shown in the upper right corner of the display - Change: Removed CrossfadeTest example; cannot work any longer because transparent windows have clip regions which prevent blitting to transparent areas - Fix: Some Protracker issues when using more than one module and/or PauseModule()/ ResumeModule() - New: ClearTimeout() can be used to stop a timeout function previously installed via SetTimeout() - New: SetTimeout() can be used to tell Hollywood that it shall call the specified function after the specified time has passed; this is very useful if your scripts needs specific timing (e.g. timing to music); you can use as many timeouts as you like; Hollywood's internal timer scheduler will manage all that for you - New: ClearInterval() deinstalls an interval that was installed using SetInterval() - New: SetInterval() allows you to install a function that is called in regular intervals (e.g. 40 milliseconds for 25fps [40 = 1000/25]); please use this function instead of polling loops! Using SetInterval() guarantees that your scripts run everywhere at the same speed! This is important because the new computers like AmigaOne, Pegasos have much more power than 68k systems; you can use as many intervals as you like; Hollywood's internal timer scheduler will manage all that for you - New: InstallEventHandler() allows you to specify functions that should be called when a specific event occurs, e.g. CloseWindow, OnMouseMove, OnKeyDown etc. - New: Added DeleteButton(), DisableButton(), EnableButton() which allow you to manage the new buttons - New: MakeButton() is the new, universal function to create v2.0-style buttons; they can monitor different events and call a function with a message instead of skipping to a label; this command supersedes CreateButton() and the %BUTTON keyword; buttons created with MakeButton() are attached to the current bgpic! - Change: Removed support for ONJOYXXX events; noone used them so I do not want to support them any longer because they do not fit in the new concept - New: The table passed to PlaySample() as argument 2 can also contain the fields "volume" and "pitch"; this is easier than to call SetVolume() or SetPitch() for the sample - New: PlaySample() can play a sample now for an exactly specified duration; just pass a table as the second argument with the field "time" initialized to the number of milliseconds the sample shall be played - Change: Removed the internal fps limiter; SetFPSLimit() and GetFPSLimit() as well as the FPSLIMIT argument/tooltype do not have a function any longer; timing should be done by the scripts - Change: Terminator -1/$FFFFFFFF in ReplaceColors() is optional now - Change: AddTab() can be called with any number of arguments now; this allows you to add multiple tabs with just one call - New: CopyFile() lets you use a callback function now which can be used to display a progress bar, confirm the overwriting of existing files and confirm the unprotection of write/delete protected files - New: GetAttribute() can also retrieve information about samples now. Attributes supported for samples are currently #ATTRTYPE, #ATTRDURATION and #ATTRPITCH - New: Unpack() unpacks a table - New: MatchPattern() returns TRUE if a string matches the specified pattern - Change: Val() can convert binary values now; simply prefix them with a '%' - New: As it does not make much sense to make InvertBrush() invert the mask and alpha channel information also, I have added two new commands which will do that: InvertMask() and InvertAlphaChannel() - New: FloodFill() command allows you to flood a bordered area in the current output device with a fill color; alpha channel and mask flooding are fully supported - Change: ReadDirectory() returns two values now: The first specifies the number of files in the directory, the second specifies the number of dirs in the directory - New: Support for percentage arguments; you can specify percent values instead of absolute values with the following functions: SetLayerTint(), SetLayerTransparency(), ScaleBrush(), ScaleAnim(), ScaleBGPic(), ChangeDisplaySize(), TintBrush(), MixBrush(), SetAlphaIntensity(), SetVolume(), SetMasterVolume(), MixRGB() simply pass the percent value as a string, e.g. "50%" - Change: Better error messages are displayed now if Hollywood cannot find a specified object; it will tell you the exact type and the id of the object it could not find - New: StringRequest() allows you to ask the user for a string or number in an easy way; requires reqtools.library - New: Hollywood's coordinate constants can be fine-tuned now, i.e. you can add or subtract values from them; e.g. DisplayBrush(1, #CENTER, #CENTER - 20) will display brush 1 slightly above the vertical center - New: GetRealColor() returns the real representation color of a given color on the current screen; e.g. $FFFFFF becomes $F8FCF8 on a 16-bit screen as we have only 5 bits for red and blue and 6 bits for green; this command is useful in connection with ReadPixel(); read the doc; GetRealColor() was already added in version 1.5 as a private command, now it's public and documented - Change: Rnd() generates 'better' random numbers now - New: SplitStr() parts a string into pieces; you need to specify a separator token (e.g. "|"); SplitStr() returns a table with the pieces as well as the number of created pieces - New: GetSamplePosition() allows you to determine the position (in milliseconds) of a currently playing sample; good for sync'ing gfx with sound; the second value returned specifies the loop counter of the sample - Change: When calling one of the SelectXXX() functions, Hollywood will preserve the following settings now: cursor position, margins and clip region; they will be restored when you call EndSelect() - Change: When displaying a transparent bgpic on AmigaOS3, Hollywood will install a clip region that matches the shape of the bgpic; so you can't display gfx on the transparent part of the window any longer => AmigaOS3 pseudo-transparent windows behave the same way as the real transparent windows under MorphOS now [VOID] - Fix: Optional argument of StrStr() was never documented; it specifies how many decimal places a float shall have and defaults to 2 - New: SetClipRegion() allows you to define a clip region for all graphics functions of Hollywood; you can use a rectangle clip region or even a custom shaped clip region by using the #SHAPE argument together with a brush whose mask will be used for the clip region then; if you use custom shaped clip regions, the drawing routines will be slower but the speed is still good (PPC supported clip routines) - New: Arc() allows you to draw partial ellipses/circles; if layers are enabled, the command will add an #ARC layer; this command is useful if you want to draw pie charts etc. - Change: DisplayTransitionFX() can no longer be used to display transparent bgpics and you can also not display a non-transparent bgpic if the current picture is transparent - Change: Hollywood uses real transparent windows now on MorphOS; looks much better but is kind of slow - New: ALPHACHANNEL prefix for the %BRUSH keyword can be used to import the alpha channel from a png image; with LoadBrush() you will have to use the optional argument number 4 to specify if you want to import alpha channel information; loading alpha channel from png pictures does currently only work with MorphOS because the OS3.9 picture.datatype does not support alpha channel; I still need to find a solution for that [ALPHACHANNEL prefix is VOID:use @BRUSH 1, "test.iff", {LoadAlpha = True} instead] - New: Effects are now negated when using UndoFX() or HideLayerFX(); e.g. #REVEALLEFT becomes #REVEALRIGHT. Certain special effects like the zoom/stretch, roll & wallpaper effects use new custom reverse effects which look much better than the ones that were used before - Change: #WALLPAPERx, #ROLLx & #PIXELZOOMx effects work with transparent objects now correctly too; looks great! - New: CropBrush() allows you to crop a brush with ease; mask and alpha channel cropping fully supported - Change: ShowLayerFX() can show all layers now (was restricted to brush and text object layers in v1.9) - Fix: Effects from the #FLOW group did not work correctly with text objects (was only broken in 1.9; it worked in 1.5) - New: MixRGB() can be used to mix two RGB colors together at a specified ratio - Change: Multiple font styles can be set with a single call to SetFontStyle() by OR'ing them into the bitmask, e.g. SetFontStyle(#ITALIC|#BOLD) - New: Anti-aliasing is back! Now fully implemented and compatible with all Hollywood functions (layers, effects etc.); Use the new #ANTIALIAS font style to activate it. Bitmap fonts can also be pseudo anti-aliased now but it is advised to use true type fonts for the real eye candy - New: DeleteAlphaChannel() removes the alpha channel from a brush - New: SetAlphaIntensity() allows you to set the intensity for rendering into a brush's alpha channel (0=100% transparency - 255=0% transparency) - New: Introducing support for alpha channels! Use SelectAlphaChannel() to render into a brush's alpha channel! Hollywood uses highly optimized routines for drawing alpha channel images which should give you satisfactory results even on 68k - New: SetRefreshMode() can be used to define the refresh mode during BeginRefresh()/EndRefresh(). Please read the documentation about it. [VOID] - New: Introducing a new animation technique: BeginRefresh()/EndRefresh(). All graphics calls that are executed after BeginRefresh() will not be drawn until EndRefresh() is called. The graphics will be cached and will be drawn by EndRefresh() without flickering. This technique can only be used with layers switched off! [VOID:use sprites] - New: Added some functions to use arrays as lists: InsertItem(), RemoveItem() and ListItems() - New: FilePos() returns a file's current cursor position - New: ReadShort(), ReadInt(), ReadFloat(), WriteShort(), WriteInt(), WriteFloat() can be used to write numbers to a file - Change: Break() and Continue() accept an optional argument now which you can use to break/continue loops in higher levels than the current one; optional argument must be specified in brackets (like Return()...) - Change: While(), For() and the If() statement now have short forms: While Do , For <...> Do and If Then ElseIf ... Else ; saves some typing :-) - Important note for the short if statement: All branches must be on a single line so that the compiler does not confuse them with a previous if statement! - Change: If a function returns one or more values, they must be enclosed in brackets so that the compiler does not confuse them with following statements - Change: SelectBGPic() can now be used to render into a background picture directly (just like SelectBrush() does); this only works when layers are switched off; with layers enabled SelectBGPic() just adds layers as you know it [VOID:removed] - New: Added Cls() command which can be used to clear the screen very fast; some restrictions apply (no layer support etc.); optional argument can be used to specify a color - New: Collision() command accepts the types #BRUSH and #LAYER now. So you can easily detect collisions between brushes and layers now. The collision detection is implemented pixel-exact with full respect to transparent areas! - New: Added %INCLUDE keyword which allows you to include code from other script files in your main project [VOID:use @INCLUDE] - New: #ATTRLAYERID allows you to find out the id of a named layer using GetAttribute() - New: You can assign names to layers now using the command SetLayerName(); this is more convenient than using layer numbers which are not constant; every command that works with layers will also accept strings now besides layer numbers - New: Added Dim() and DimStr() for easy array creation & initialization; if used in a function, they create local arrays - New: Added With ... EndWith statement for easy access to data members [VOID; not going to be supported; you can use metatables for that purpose (__index metamethod; also takes a table as argument)] - New: SaveSnapshot() allows you to create snapshots of your scripts easily; you can make snapshots of your display, the host window and even of the whole desktop screen with this function - New: SaveBrush() can save brushes to a file - New: Added a function for easy detection of collisions: Collision(); it currently supports only the type #BOX but there is more to come - New: Added the popular "immediate if" statement IIf(). This is a very compact version of the if-statement. Please keep in mind that both true and false values are evaluated in every case - no matter if the condition is true or false: IIf(a <> 0, 5 / a, 0) --> this won't work for a:=0 (division by zero error) - Change: ShowLayer() accepts two optional arguments which can be used to re-position the layer - New: Added %DISPLAYPOSITION keyword which can be used to set the position where the Hollywood display shall be opened on the screen (defaults to #CENTER/#CENTER) [VOID:use @DISPLAY {X=, Y=}] - New: CopyAnim() can be used to copy a whole animation to a new anim object; useful e.g. in connection with ScaleAnim() - New: CreateAnim() allows you to create animations from brush sources; very useful if you do not want to use IFF ANIMs because they only work with a correct animation.datatype (which MorphOS does not have currently) - New: #NEXTFRAME type is now supported by AddMove(). This makes animation via DoMove() much easier because you do not have to do all the #BRUSH/#HIDEBRUSH stuff with many different brushes any more. Just use one anim layer and change its frames! - Change: InsertLayer() can insert #ANIM layer types now too - New: #ATTRNUMFRAMES allows you to find out how many frames the specified anim object has; #ATTRCURFRAME can be used to find out the frame which is currently displayed in the specified anim layer - New: NextFrame() displays the next frame of the specified anim layer or jumps to a specific frame (if the optional argument is specified) - New: Real anim layers are supported now! This means that you can display all frames of an animation in one single layer. Very useful! - Change: Brush links are now fully dynamic; if the source object of a brush link changes, the linked brush will be updated also [VOID:brush link support was completely removed; emulation provided] - Fix: Several fixes in connection with brush links - Change: Extended the PolygonTest example script with some fill style buttons to demonstrate this new feature - Fix: #USELAYERPOSITION was added but not documented in Hollywood 1.9 - New: Added two new fill styles for the graphics primitives draw functions: #FILLGRADIENT and #FILLTEXTURE allow you to draw gfx primitives filled with a gradient or textured - New: Rewrote the whole image processing kernel of Hollywood. Expect DRAMATIC speed increases on classic Amigas (like 10 times faster...); modifying images is now done without any overhead; on WarpOS the PPC is used to compute the new images. Try the ImageLab example with Hollywood 2.0 and you'll see what I mean! Also, many of the transition fx which include zooming run more than twice as fast now...enjoy! It doesn't get any faster. - Change: guigfx.library and render.library are not required by Hollywood any longer (because palette support is gone now) - Change: Hollywood does not run on palette screenmodes any longer. This step was long overdue; palette screens are a thing of the past. Get over it :) - Change: #BLEND fx can be used with BGPics now again (was already possible in v1.0 but not in v1.5 - v1.9) - New: CreateGradientBGPic() accepts an optional argument now which specifies the rotation in degrees for the gradient; argument #2 specifies the gradient type now (currently defined is #LINEAR only); compatible with Hollywood 1.x - Change: Data files declared in the keywords section will be loaded now after the script was compiled successfully; so if you want to check for syntax errors, you do not have to wait the whole time until the data is loaded - Change: ReadPixel() returns only 0 or 1 if SelectMask() is in use (0 means pixel is transparent, 1 = non transparent) - Change: Color parameter of Box(), Plot(), Circle(), Ellipse() and Polygon() is optional now because if SelectMask() is active, we do not need it - New: SetMaskMode() can be used to choose the render mode for SelectMask(); two arguments are possible: #MASKVISIBLE and #MASKINVISIBLE - New: SelectMask() allows you to render into the mask of a brush; this makes nice custom transparency effects possible - Change: RotateBrush() creates a mask automatically now for every brush you rotate; if the brush already has a mask, RotateBrush() will rotate it too; no need to call SetBrushTransparency() any longer after calling RotateBrush() - Change: MixBrush() respects transparent area in the second brush now - New: MoveDisplay() allows you to change the position of the display window - Fix: Cursor position will be reset to 0:0 now when you display a new BGPIC - New: Added some functions to manipulate memory directly (only for advanced users): AllocMem(), FreeMem(), Peek(), Poke(), FillMem(), CopyMem(), ReadMem(), WriteMem() and DumpMem(); but there are no pointers! These functions are designed to work with memory handles so they are safe in every case - New: CRC32() calculates the CRC-32 checksum of a given file - New: IsDirectory() checks if the given argument is a file or a directory - New: Rename() command added to change the name of files or directories - New: CopyFile() command allows you to copy single files or even whole directories (full recursion!); Comments, attributes and date stamps are copied also; patterns can also be specified - New: DeleteFile() can also delete whole directories now; patterns can be specified and callback functions are supported also; read the documentation - New: OpenFile() can now open a file also in read- or write-exclusive mode - Fix: The #SCROLLxxx effects will add now a #BGPICPART layer instead of #BRUSH layer when using DisplayBGPicPartFX() - Change: FreeBrush(), FreeAnim(), FreeTextObject() and FreeBGPic() will free all layers that refer to the object now also [VOID:layers will be substituted instead; reason:compatibility] - Change: DisplayBGPicPartFX() accepts now destination x,y and layers arguments just like DisplayBGPicPart() does - Fix: Layers that are not visible because their coordinates were out of the display could cause an error with some commands - New: GetType() returns the type of the variable passed in - Change: Hollywood's window is no longer a GZZ (gimme zero zero) window - Change: InKeyStr() leaves only one #PRINT layer on the display instead of separate layers for all chars - Change: WaitKeyDown() waits now until the key is up again - Change: Print() and NPrint() accept any number of arguments now - Change: SetLayerLight() is now called SetLayerTint() because light is a bit confusing; the old command still works for compatibility - Change: FileRequest() accepts an optional mode argument now which allows you to open the requester in save or multiselect mode - New: PathRequest() pops a requester which allows the user to select a path - New: FullPath() combines filename and directory to a fully qualified path - New: BinStr() converts a value to a string with 32 bits - Change: CreateRainbowBGPic() is now called CreateGradientBGPic() because a gradient is not always a rainbow ;-) The old name can still be used but is considered obsolete now - New: ScaleBGPic(), ScaleBrush(), ScaleAnim() and ChangeDisplaySize() accept the new constant #KEEPASPRAT now which calculates the missing size automatically according to the aspect ratio of the bgpic/brush/anim/display - Fix: DisplayBrushPart() did not accept special coordinate constants - Change: DebugPrint() superseded DebugVal() and DebugStr(); supports any number of arguments now - New: CtrlCQuit() allows you to turn the control-c quit option on and off - New: #HOLLYWOOD constant holds the Hollywood version string now - Change: String and float values for constants are now possible too - Change: Val() returns another argument now which tells you how many characters it converted - New: Min() and Max() accept any number of arguments now - New: Constant #PI - New: Added math functions ASin(), ACos(), ATan(), ATan2(), Ceil(), Floor(), Exp(), Deg(), Rad(), BitTest(), BitSet(), BitClear(), BitXor(), BitComplement(), Sgn(), Limit() - Change: SetVarType() is obsolete now; there are easier ways to work with arrays now - New: Rewrote several integral parts of Hollywood for better performance and less memory consumption - New: Colon between commands on one line is no longer necessary - New: Constants can be defined after the %CODE keyword now using the identifier Const - New: Local variables. Do not use them together with GOTO/GOSUB! - New: Support for character constants using 'x' (up to 4 bytes) - New: Hex numbers can be prefixed with 0x also now - New: Support for long strings (strings split over multiple lines) - New: Functions, multi-dimensional arrays & structures are possible now - New: Continue() can be used to jump to the end of a loop - New: Break() can be used to break loops and the Switch-Case statement - New: Added new statements for controlling the program flow: Switch-Case- EndSwitch, Repeat-Until, Repeat-Forever, Block-EndBlock, For-In-Next (Generic For using iterator functions) - New: Expression support. Operators: + (plus), - (minus), * (multiply), / (divide), \ (integer divide), % (integer modulo), << (left shift), >> (right shift), & (bit and), ~ (bit xor), | (bit or), AND (logical and), OR (logical or), NOT (logical not), ^ (power), .. (concatenate), - (negation), ~ (bit negation) - New: Hollywood uses 64-bit variables now. This allows you to store really big numbers and floats! - New: Added a fully-featured, state of the art programming language for Hollywood. The new language is based on the kernel of the light-weight application extension language Lua. The syntax and functionality however is in many ways different from Lua but the most powerful features like dynamically-typed scripts are kept of course. You will soon notice the power of this new language which allows you to create full-blown applications now with Hollywood. Please read the Hollywood documentation for an introduction to the new language. Compatibility with the Hollywood 1.x is almost fully guaranteed. Please read API-Changes.txt for more information. This is what you have been waiting for. Hollywood finally has a modern scripting language suitable for all purposes. - Started work on Hollywood 2.0 (April 2004). Version 1.93 (18-Mar-05) - Change: Updated GUI - Change: Updated Settings tool and documentation - New: Added PPC-native AmigaOS4 version and cross-compiler so that you can create AmigaOS4 executables on each Hollywood platform - Change: Slightly changed the Protracker implementation because of problems with AHI on OS4 (now using ptahiplay.library v2.0) - Fix: Illegal memory access which caused a crash on OS4 - Fix: Redraw problems with transparent windows on OS4/MorphOS when moving them out of the screen - Fix: Several AHI fixes/improvements - Fix: #CLOSEWINDOW event was not activated upon startup (only in 1.9) - Fix: When using a borderless window together with the SIZEABLE argument, the size gadget got lost after the first manual resize operation - Fix: Chr() did not always work as expected - Fix: #DIAGONAL did not always work because a variable initialization had been forgotten - Fix: Width calculation was not correct for all font types - Fix: TextOut() and CreateTextObject() sometimes created a broken text object when alignment was #RIGHT - Fix: Sort() was broken Version 1.92 (20-Aug-04) - Change: Updated Hollywood documentation - Change: Updated GUI - Change: Updated Settings tool and documentation - Fix: StrLen() was not documented in the German guide file - Fix: #STAR wipe caused a crash on some Amithlon systems; uses a work-around now because I do not really know what caused the crash (reported by Don Cox) - New: Added STAYACTIVE argument/tooltype which forces the window to stay always active. This is useful with a borderless window on an own screen. The user could accidentally deactivate the window without noticing it and then the window would not receive any more messages which could confuse the user - New: Added FULLSCREEN argument/tooltype which turns on all the options you need for a nice, professional full screen display - Fix: Loading an IFF picture (or something else) as a sample crashed Hollywood after displaying the error message (reported by Don Cox) - New: In the Settings tool, you can specify the optional tooltype AMIGAOS3, MORPHOS and WARPOS. This allows you to include only ONE Settings tool which can be used to configure ALL of your executables for different platforms - Change: GUI displays Scala scripts now too in the file requester (requested by Don Cox) - Fix: Wait() does no longer eat up all your CPU power (reported by Anarka) - Fix: Another SetBrushTransparency() bug when the screen is using BGRA32 pixels (reported by hooligan/dcs) - Fix: CreateTextObject() leaked a few bytes per call (reported by Robin) - Fix: When Hollywood cannot obtain its exclusive pen on RTG screens it will use a shared pen now (reported by Don Cox) - New: Hollywood can be interrupted now by pressing CTRL-C - Fix: Some error messages were too long to be displayed correctly (reported by Costel Mincea) - Fix: Window contents of the GUI and the Settings tool were not always refreshed (reported by Jacek Piszczek) - Fix: SetBrushTransparency() did not work correctly on graphics boards using BGRA32 pixel format (reported by Mahendra Tallur, Costel Mincea) - Fix: Some commands did not wait for the blitter to be finished which could cause a broken display on native graphics.library systems and also on Picasso96 which still seems to use the blitter (!) Version 1.9 (08-Apr-04) - New: Added GetSongPosition() and GetPatternPosition() - New: Added four new examples: Boing Attack! (high-end), Circle Text, Polygon Test and Wavy Logo - Change: Updated CreditsRoll, Da Cool Quiz, Object Transition FX, WinFileCopy, Fireworks, Puzzle, Rainbow Creator, Welcome, Transition FX examples for Hollywood 1.9 - New: Added catalog descriptions for developing your own catalogs. Hollywood.cd, Settings.cd and GUI.cd can be used to translate Hollywood into your language - Change: Updated the Settings tool - Change: Reworked the GUI a bit and added support for WarpOS in the GUI too (when compiling a script) - Change: PlayAnimDisk() supports an additional argument now which specifies how many times the animation shall be played - New: Italic, bold and underline styles are supported now also for color, truetype and intelli fonts - New: A lot of new transition effects have made their way into Hollywood 1.9. Here's a list: #CLOCKWIPE, #STAR, #HSTRANGEPUSH, #VSTRANGEPUSH, #SLIDELEFT, #SLIDERIGHT, #SLIDETOP, #SLIDEBOTTOM, #SPIRAL, #SWISS, #QUADRECT, #HSPLIT, #VSPLIT, #UPNDOWN, #CARDTOP, #CARDBOTTOM, #SUN, #WATER1, #WATER2, #WATER3, #WATER4, #STRUDEL, #DISSOLVE, #PIXELZOOM1, #PIXELZOOM2, #ZOOMIN, #ZOOMOUT, #CRUSHLEFT, #CRUSHRIGHT, #CRUSHTOP, #CRUSHBOTTOM, #VFLIPCOIN, #VLOWFLIPCOIN, #HFLIPCOIN, #HLOWFLIPCOIN, #TURNDOWNTOP, #TURNDOWNBOTTOM, #TURNDOWNLEFT, #TURNDOWNRIGHT, #WALLPAPERLEFT, #ROLLLEFT, #TYPEWRITER (this is a text object only effect!); please note that the following effects are considered "high-end" and are therefore very slow on 68k: #WATER 1-4, #STRUDEL, #WALLPAPERLEFT; if you use #RANDOMEFFECT with the 68k version of Hollywood, the program will not choose any high-end effects - New: Hollywood is now available in a separate version for WarpOS and it can also create executables for WarpOS now! - New: Box() accepts an additional argument now that allows you to create a rectangle with rounded corners - New: Polygon() allows you to draw polygons - Change: Precalculation is no longer supported. Get a faster Amiga. - Fix: Generated executables did not work from Workbench when they had a space in the filename - Change: When using the screenmode requester, Hollywood will suggest a screenmode now that would fit - New: If STARTCOLOR and ENDCOLOR are specified together with BACKFILL=PICTURE, you will get a gradient as the background with the picture on top - New: PICTRANS argument allows you to give your picture a transparency setting (only applicable if BACKFILL=PICTURE) - Fix: STARTCOLOR and ENDCOLOR were in the wrong order when using BACKFILL=RAINBOW - Fix: MoveXXX() and the #SCROLLXXX effects were not always exact - New: PICXPOS & PICYPOS arguments/tooltypes allow you to position the picture in the backfill window (only applicable if BACKFILL=PICTURE); special constants like #LEFT, #RIGHT... may be specified - New: SCALEPICTURE argument/tooltype scales the picture to the dimensions of the backfill window (only applicable if BACKFILL=PICTURE) - New: BESTFIT argument/tooltype will select the screenmode automatically for you (DEPTH may be specified too) - New: HideLayerFX() allows you to hide layers with a transition effect - New: Added BreakWhileMouseOn() which is useful in some cases (see documentation) - Change: WhileMouseOn() did not really work as it was meant to be. This change could lead to an incompatibility with old scripts! Please read APIChanges.txt for more information - Fix: Moving a box that was created with #FILLNONE and has a transparency assigned did not work correctly - New: You can use Hollywood with FBlit now! If you have lots of fast memory but no graphics board, install FBlit with the AllocBitMap() patch activated and Hollywood will use your fast memory for all graphics data. Very useful. But never ever use FBlit if you have a graphics board! - Fix: Hollywood could crash totally when running out of memory during the display setup. Sorry for that. - Change: Improved the way of color handling on RTG systems - New: Added commands Red(), Green(), Blue() and RGB() for easy access to RGB values - Change: You can free the BGPIC that is currently displayed now with FreeBGPic(); Hollywood will install a temporary picture then which will only be visible if areas need to be redrawn - Change: Optimized the DoMove() command for more speed. It requires more memory now but is possibly a lot faster by using a new technique - Change: Box() command improved + speed-up - Change: Wait() accepts an optional argument now which specifies the wait precision; so you can have real precise waits now (by using #MILLISECONDS as the optional argument) - New: SetPanning() allows you to define where samples are played (ranges from 0 to 255; left speaker only = 0, both speakers = 128, right speaker only = 255) - New: ShowLayerFX() can show layers with a transition effect (currently only works with BRUSH and TEXTOBJECT layer types) - New: InsertLayer() supports type #TEXTOBJECT now and can insert hidden layers - Fix: InsertLayer() was totally broken in v1.5 - Fix: Enforcer hit when calling WhileMouseOn() with no active button - Change: Roll transition effects work now with objects also - Fix: StopTimer() works now (reported by Telemar Rosenberger) - New: Added CheckEvent() as a much more flexible replacement for the removed EventHandler() functions - Change: As announced in previous versions: EnableEventHandler() and DisableEventHandler() are gone now - Change: Rewrote the whole event handler part; most events are now cached for a specified time. Use SetEventTimeOut() to define it. - Change: New technique for redrawing portions of the old background picture when using DisplayTransitionFX(); avoids some problems - Change: #HOPENGATE, #HCLOSEGATE, #VOPENGATE & #VCLOSEGATE effects do not work with objects any longer; they did not really fit to objects - New: German catalog for Hollywood - New: Added German guide! Big thanks to Alexander Pfau for doing this really huge work! - New: Finally added locale.library support! Experience Hollywood in your language now! - Fix: Program crash when trying to display a transparent picture with a transition effect (when switching from a non-transparent picture) - Fix: Running multiple versions of Hollywood did not work in full screen mode - Fix: When compiling a script in the GUI, the GUI did always say "success" even if an error occurred (reported by Jean-Yves Auger) - Change: GUI can be controlled now by keyboard - Fix: GUI works now also on 640x480 screens - New: MoveLayer() allows you to smoothly scroll layers across the display; the function works exactly like the other MoveXXX() functions - New: The MoveXXX() function group accepts a new optional argument for some special effect like bouncing, damped, sine, curve, smooth out etc. - New: Added #SCROLLNORTHEAST, #SCROLLSOUTHEAST, #SCROLLSOUTHWEST and #SCROLLNORTHWEST transition effects - Change: Reimplemented the #SCROLLXXX transition effects group; it allows now the scrolling of brushes and other objects too and it can also be undone properly (runs the effect in reverse mode!) - Change: Rewrote some transition effects for more speed on 68k - Fix: Margin settings were not adapted after a display resize (reported by Jörg Renkert) - Fix: Dragbar and size gadget could disappear after a display resize (reported by Jörg Renkert) - Fix: Hollywood works on DraCo now (thanks to Michael Burkhardt) - Change: lowlevel.library is no longer opened at the start; it will only be loaded when joystick input is required - Change: Rewrote some input handling code to decrease CPU usage in idle mode - Fix: GUI no longer eats up all your chip memory - Fix: ptahiplay.library could not be flushed from memory in version 1.5 - Fix: Most of the sample control functions were broken under certain conditions (reported by Telemar Rosenberger) - Change: MakeDirectory() will scan the whole path now and create all directories that do not exist - Fix: Confusing transition effect names in the #RECTBACKXXX group - Fix: Removed useless code which was only required in Hollywood 1.0 but I forgot to remove it in 1.5 and it slowed down color font loading - Fix: Special event labels like ACTIVEWINDOW, INACTIVEWINDOW, ONBUTTONCLICKALL, ... did not work in compiled scripts (reported by Robin Hueskes and Telemar Rosenberger) Version 1.5 (19-Jun-03) - New: Added free settings tool and the GUI uses MUI now and has some extended features - New: Added new examples: Fireworks, WBFadeOut, WobbleText, TextZoom, Vectorballs, SinusScroller, Blanker, Lens, ImageLab, Amiquarium; updated all the old ones to work with Hollywood 1.5 - Change: Hollywood will switch now automatically to BORDERLESS mode if the script cannot be displayed just because of the window borders size - Change: identify.library is no longer required - Change: Removed GetSystemInfo() as it did no longer fit in the concept - Change: MorphOS compiled scripts use now a PPC-native startup code instead of 68k code - New: EXETYPE argument/tooltype lets you specify which executable type the compiler shall output; currently supported: CLASSIC and MORPHOS - New: %DISPLAYDESKTOP keyword starts with the desktop (Workbench) as the initial BGPic - New: GetAttribute() recognizes type #LAYER now with attributes #ATTRTYPE, #ATTRWIDTH, #ATTRHEIGHT, #ATTRVISIBLE, #ATTRXPOS & #ATTRYPOS - Fix: Some arrays were not imported correctly when using a compiled script (reported by Wil Haslup, Jörg Renkert) - Change: MoveXXX() rewritten; about 50% faster now - New: Added some additional arguments/tooltypes: NOSOUND globally disables all sound routines, PRECALCULATION turns on precalculation for cpu intensive effects and FIXED opens Hollywood's window as not movable - New: Introducing support for Intellifonts! - New: 16-bit samples are supported now through sound.datatype v41 by Stephan Rupprecht (optional; if you only use 8-bit samples you can keep the old one!) - New: RndF() returns a random float between 0 and 1 just like in many other languages - New: MakeDirectory() creates new directories - New: EscapeQuit() works the same way like LeftMouseQuit() but Hollywood will quit when the user presses ESCape at any time - New: ScaleBGPic() can scale your background pictures - New: Added various operations for brushes: ReplaceColors(), InvertBrush(), RotateBrush(), BrushToGray(), FlipBrush(), MixBrush(), TintBrush() - New: SetPointer() can replace the default mouse pointer with your own one (requested by Telemar Rosenberger) - New: SetLayerTransparency() and SetLayerLight() allow you to change the way a layer is displayed (this is very slow because heavy calculations are necessary) - Change: Removed #CROSSFADEPRECALC, #BLENDPRECALC & #FADEPRECALC. Precalculation should be specified by using EnablePrecalculation() - Change: SetPitch() and SetVolume() work also now when the sample is not playing - Change: Documentation was updated - New: GetBrushLink() supports #BGPIC and #TEXTOBJECT now - Change: GetTimer() supports now an additional argument which specifies if you want the time in seconds or milli-seconds - New: AddMove() supports now #UNDO and #REMOVELAYER - New: Master volume control implemented through the commands GetMasterVolume() and SetMasterVolume() and the argument MASTERVOLUME - New: InKeyStr() allows you to read full strings, numbers etc. from the keyboard (requested by Christoph Gutjahr) - New: Improved keyboard support: WhileKeyDown(), WaitKeyDown(), IsKeyDown() - New: AddMove() supports now new types: #LAYER, #HIDELAYER, #HIDEBRUSH and #INSERTBRUSH - New: RemoveLayer(), SwapLayers(), ShowLayer(), HideLayer(), FreeLayers() and InsertLayer() implemented for the ultimate layer control - New: Attribute #ATTRLAYERS returns number of layers for a specified BGPic or for the display - New: Undo() accepts an additional boolean for silent undo - New: You can declare your own constants now by using the keyword %CONSTANT - New: Constants for 16 basic colors: #BLACK, #MAROON, #GREEN, #OLIVE, #NAVY, #PURPLE, #TEAL, #GRAY, #SILVER, #RED, #LIME, #YELLOW, #BLUE, #FUCHSIA, #AQUA, #WHITE - New: GetBrushLink() can get links to other brushes also - New: Keyword %DISPLAYCOLOR allows you to specify a background color when using a blank display - New: HexStr() converts a value to a hex string - New: Even more new math functions: Abs(), Min(), Max(), Mod(), Shl(), Shr(), Pow(), Sqrt(), Round(), Int(), Frac(), Log(), Ld(), Ln(), Rt()...enjoy! - Change: Undo system is now fully integrated with layers; you can enable and disable the whole system by just calling EnableLayers() / DisableLayers() - Change: Constants must be accessed now by using the '#' prefix; I'm sorry but this change was absolutely necessary. I wish I would have implemented it this way right from the start but I didn't. Therefore you will have to adapt your scripts now. - New: Hollywood will load now MS-DOS formatted scripts also (with carriage return + linefeed) - New: ClearEvents() kills all defined events - New: Correct support of loop frames for Anim5 animations and Deluxe Paint anim brushes - New: TextHeight() returns height of a string rendered with the currently selected font - Fix: Big String array bug fixes which caused a lot of trouble (reported by Christoph Gutjahr, Andreas Laaser, Marco Reuters) - New: GetAttribute() can return the transparent color of objects now by using #ATTRTRANSPARENTCOLOR. And it can also return the currently displayed BGPic by using GetAttribute(#DISPLAY, 0, #ATTRBGPIC) - New: You can use the events ONBUTTONCLICKALL, ONBUTTONRIGHTCLICKALL, ONBUTTONOVERALL and ONKEYDOWNALL to query global input through these few labels; the id of the event can be retrieved by calling GetEventCode() - Change: Reprogrammed event handler; more flexible now and it can also disable events like SIZEWINDOW, CLOSEWINDOW... - New: You can also query the Joystick state by using JoyDir() and JoyFire() - New: Introducing Joystick support: Use labels ONJOYUP[x], ONJOYUPRIGHT[x], ONJOYRIGHT[x], ONJOYDOWNRIGHT[x], ONJOYDOWN[x], ONJOYDOWNLEFT[x], ONJOYLEFT[x], ONJOYUPLEFT[x], ONJOYFIRE[x] to catch Joystick input. [x] is the port number (normally you will want to use 1 which is the game port) - New: You can specify one of the following constants for transition effect speed: #SLOWSPEED, #NORMALSPEED, #FASTSPEED. Hollywood will choose the correct speed setting then by itself - New: A lot of cool new transition effects: #RECTCENTER, #RECTNORTH, #RECTNORTHEAST, #RECTEAST, #RECTSOUTHEAST, #RECTSOUTH, #RECTSOUTHWEST, #RECTWEST, #RECTNORTHWEST, #SCROLLLEFT, #SCROLLRIGHT, #SCROLLTOP, #SCROLLBOTTOM, #STRETCHLEFT, #STRETCHRIGHT, #STRETCHTOP, #STRETCHBOTTOM, #HSTRETCHCENTER, #VSTRETCHCENTER, #ZOOMCENTER, #ZOOMNORTH, #ZOOMNORTHEAST, #ZOOMEAST, #ZOOMSOUTHEAST, #ZOOMSOUTH, #ZOOMSOUTHWEST, #ZOOMWEST, #ZOOMNORTHWEST, #HFLOWTOP, #HFLOWBOTTOM, #VFLOWLEFT, #VFLOWRIGHT, #HOPENGATE, #HCLOSEGATE, #VOPENGATE, #VCLOSEGATE, #PUSHLEFT, #PUSHRIGHT, #PUSHTOP, #PUSHBOTTOM, #PUZZLE, #DIAGONAL, #ROLLTOP, #WALLPAPERTOP, #RECTBACKCENTER, #RECTBACKNORTH, #RECTBACKNORTHEAST, #RECTBACKEAST, #RECTBACKSOUTHEAST, #RECTBACKSOUTH, #RECTBACKSOUTHWEST, #RECTBACKWEST, #RECTBACKNORTHWEST - New: Introducing Hollywood moves: Use AddMove(), DoMove(), ClearMove() to move as many objects as you want in one drawing operation (requires layers) - New: ReadPixel() reads a single pixel from the current render device - Change: Backfill code is more flexible now - New: STARTCOLOR can also be used now together with BACKFILL=PICTURE - New: BRUSHFILE can be specified instead of BRUSH in argument list - New: BACKFILL can now be used also on Workbench - Change: Better algorithm for CreateRainbowBGPic() - Fix: Box() drawed the box too large (+1 width, +1 height) - New: EnablePrecalculation() + DisablePrecalculation() - global control over precalculation - Fix: Crash with variables that used long names - New: LoadAnimFrame() and PlayAnimDisk() for the ultimate anim control PlayAnimDisk() graphics can be undone by using #ANIMDISK object - New: SetBrushTransparency() and CopyBrush() - Change: DisplayBGPicPart() has more functions now - Fix: WriteLine(), WriteChr() and WriteString() could cause problems - New: SetFillStyle() allows you to specify a filling style for the drawing functions (Ellipse(), Circle(), Box()) - New: Protracker modules are also played now using AHI; this allows you to play samples and modules at the same time using full channel mixing! Support for P61, THX & MED modules has been dropped; might be re-implemented later using a plugin - New: AHI is now used for playing samples; syntax of PlaySample() has changed, check the documentation - New: Frames per second are limited now to 30 to keep the timing upright on PPC machines; you can modify this limit by using the SetFPSLimit() command. I never thought that such a limit would be needed but Hollywood on the Pegasos is really too fast :-) - Change: Removed Rainboot emulation; will be re-implemented later using a plugin - Change: Removed IsAnimPlaying() and WaitAnimEnd(); they are no longer necessary because PlayAnim() runs synchronously now - Change: PlayAnim() runs synchronously now; this had to be changed because the old PlayAnim() from Hollywood 1.0 did not really fit into the concept - New: Introducing off-screen rendering with SelectBGPic() and SelectBrush(); some restrictions apply; read the documentation - New: GetBrushLink() command allows easy access to single anim frames by linking them to a brush id; please read the documentation about brush links - New: #PRINT, #BGPICPART, #BRUSHPART, #BOX, #CIRCLE, #ELLIPSE, #PLOT, #ANIM support for Undo() and UndoFX() - Change: Reworked Print(), TextOut() and CreateTextObject(). They are slower now but fully compatible with layers and undo and just everything!! - Fix: Shift key no longer raises false events (reported by Andreas Laaser) - New: Create blank gfx objects of any size with CreateBrush() and CreateBGPic() - New: Right mouse support - IsRightMouse(), WaitRightMouse(), WhileRightMouseDown() and ONBUTTONRIGHTCLICK (requested by Christoph Gutjahr) - Change: Improved float support - New: MouseX() and MouseY() return the current mouse position (requested by several users) - New: More math functions - Sin(), Cos(), Tan() and Wrap() - New: PUBSCREEN argument which allows Hollywood to appear on any public screen (requested by Andreas Laaser) - New: Layers support! Call EnableLayers() to install it (recommended) - Change: Improved the handling of transparent windows - Change: Removed ClearScreen() command; did no longer fit in the concept - Fix: MidStr() started at character 1 and not at 0 - Change: Faster memory allocation for large scripts - New: Undo() & UndoFX() allow user to specify an undo-level - New: CreateTextObject() accepts now an optional argument which specifies the text alignment for new lines - Fix: "Line 1004" bug which caused a guru at Hollywood's termination - Fix: Bug in ResetTabs() Version 1.0 (04-Nov-02) - First Release @ENDNODE @Node HashChar "Guide Hollywood" @{b} caractère # @{ub}     Le caractère @{b}#@{ub} est utilisé comme préfixe pour les @{b}constantes@{ub}. Voir le     chapitre @{"constantes" LINK V6PrgConstants} pour plus d'informations. @ENDNODE @Node PercentChar "Guide Hollywood" @{b} caractère % @{ub}     Le caractère @{b}%@{ub} est utilisé soit comme préfixe pour les @{b}mots clés@{ub} ou comme l'@{b}opérateur modulo@{ub}.     @{b}Mots-clés@{ub}:     Voir le @{"chapitre mots-clés" LINK V6PrgPreproc} pour plus d'informations.     @{b}Opérateur modulo@{ub}:     Voir les @{ "opérateurs arithmétiques" LINK V6PrgOprArith} pour plus d'informations. @ENDNODE @Node ExclamationChar "Guide Hollywood" @{b}caractère !@{ub}     Le caractère @{b}!@{ub} est souvent utilisé pour indiquer les @{b}variables de type virgule flottante@{ub}.     Voir le chapitre @{"types de données" LINK V6PrgTypeIntro} pour plus d'informations. @ENDNODE @Node 0xChar "Guide Hollywood" @{b}caractère 0x @{ub}     Les caractères @{b}0x@{ub} sont utilisés comme préfixe pour un @{b}nombre hexadécimal@{ub},     par exemple 0xff = 255. @ENDNODE @Node DollarChar "Guide Hollywood" @{b}caractère $@{ub}     Le caractère @{b}$@{ub} est souvent utilisé pour indiquer les @{b}variables de type chaîne de caractères@{ub}.     Voir le chapitre @{"types de données" LINK V6PrgTypeIntro} pour plus d'informations.     En outre, le caractère @{b}$@{ub} est utilisé comme préfixe pour @{b}un nombre hexadécimal@{ub},     par example $FF = 255. @ENDNODE @Node BackslashChar "Guide Hollywood" @{b}caractère \\ @{ub}     Le caractère @{b}\\@{ub} est utilisé soit comme un @{b}préfixe à une séquence de codes d'échappement@{ub} ou comme     l'opérateur de @{b}division entière@{ub}.     @{b}Séquence de codes d'échappement @{ub}:     Voir le chapitre @{"chaîne de caractères" LINK V6PrgTypeString} pour plus d'informations.     @{b}Opérateur de division entière @{ub}:     Voir les @{"opérateurs arithmétiques" LINK V6PrgOprArith} pour plus d'informations. @ENDNODE @Node CommentChar "Guide Hollywood" @{b}Caractère / * .... * /@{ub}     La séquence @{b} / * .... * / @{ub} est utilisée pour un @{b} commentaire @{ub}. Voir le     chapitre @{"commentaire" LINK V6PrgComments} pour plus d'informations. @ENDNODE @Node SemicolonChar "Guide Hollywood" @{b} caractère ;@{ub}     Le caractère @{b};@{ub} indique un @{b}commentaire@{ub}. Voir le chapitre @{"commentaires" LINK V6PrgComments}     pour plus d'informations. @ENDNODE @Node SingleQuoteChar "Guide Hollywood" @{b}caractère @{ub}     Le guillemets simple @{b}@{ub} est utilisé pour encadrer les @{b}constantes de caractères@{ub}. Voir la documentation de @{"caractère constant" LINK V6PrgCharacterCst} pour plus d'informations. @ENDNODE @Node AtChar "Guide Hollywood" @{b} caractère @ @{ub}     Le caractère Arobase (@{b} @ @{ub}) est utilisé pour préfixer les commandes pré processeur. Voir     le chapitre @{"commandes pré processeur " LINK V6PrgPreproc} pour plus d'informations. @ENDNODE @NODE V6Reference "Guide Hollywood" @{b}Référence@{ub} @{"# Caractère " LINK HashChar} langage de base du Script @{"% Caractère " LINK PercentChar} langage de base du Script @{"! Caractère " LINK ExclamationChar} langage de base du Script @{"$ Caractère " LINK DollarChar} langage de base du Script @{"0x Caractère " LINK OxChar} langage de base du Script @{"; Caractère " LINK SemicolonChar} langage de base du Script @{"\\ Caractère " LINK BackslashChar} langage de base du Script @{"' Caractère " LINK SingleQuoteChar} langage de base du Script @{"@ Caractère " LINK AtChar} langage de base du Script @{"^ Opérateur " LINK V6PrgOprArith} Opérateur arithmétique @{"* Opérateur " LINK V6PrgOprArith} Opérateur arithmétique @{"/ Opérateur " LINK V6PrgOprArith} Opérateur arithmétique @{"\\ Opérateur " LINK V6PrgOprArith} Opérateur arithmétique @{"% Opérateur " LINK V6PrgOprArith} Opérateur arithmétique @{"+ Opérateur " LINK V6PrgOprArith} Opérateur arithmétique @{"- Opérateur " LINK V6PrgOprArith} Opérateur arithmétique @{"= Opérateur " LINK V6PrgOprRelat} Opérateurs relationnel @{"<> Opérateur " LINK V6PrgOprRelat} Opérateurs relationnel @{"< Opérateur " LINK V6PrgOprRelat} Opérateurs relationnel @{"> Opérateur " LINK V6PrgOprRelat} Opérateurs relationnel @{"<= Opérateur " LINK V6PrgOprRelat} Opérateurs relationnel @{">= Opérateur " LINK V6PrgOprRelat} Opérateurs relationnel @{"<< Opérateur " LINK V6PrgOprBitw} Opérateur Binaire @{">> Opérateur " LINK V6PrgOprBitw} Opérateur Binaire @{"& Opérateur " LINK V6PrgOprBitw} Opérateur Binaire @{"| Opérateur " LINK V6PrgOprBitw} Opérateur Binaire @{".. Opérateur " LINK V6PrgOprStrng} Concaténation de chaîne @{"/* ... */ Caractère " LINK CommentChar} langage de base du Script @{"ACTIVEWINDOW Evénement " LINK ACTIVEWINDOW} Compatibilité entre fonction et événement @{"Abs() Commande " LINK Abs} Fonction mathématique @{"ACos() Commande " LINK ACos} Fonction mathématique @{"Add() Commande " LINK Add} Fonction mathématique @{"AddMove() Commande " LINK AddMove} Fonction Calque (layer) @{"AddTab() Commande " LINK AddTab} Fonction graphique @{"AddStr() Commande " LINK AddStr} Fonction chaîne de caractère @{"A propos d'Hollywood " LINK Philosophy} La philosophie derrière le programme @{"AllocMem() Commande " LINK AllocMem} Fonction bloc mémoire @{"And Opérateur " LINK V6PrgOprLogic} Opérateurs Logique @{"@ANIM Commande préprocesseur " LINK atANIM} Fonction animations @{"%ANIM Mots clé " LINK ANIM} Fonction animations @{"Fonction animations " LINK V6LibGfxAnim} Description @{"Animation techniques " LINK V6PrgG2KAnimation} Bon à savoir @{"API changes " LINK APIChanges} Package Hollywood @{"@APPAUTHOR Commande préprocesseur " LINK atAPPAUTHOR} Commande préprocesseur @{"@APPCOPYRIGHT Cmde préprocesseur " LINK atAPPCOPYRIGHT} Commande préprocesseur @{"@APPDESCRIPTION Cmde préprocesseur " LINK atAPPDESCRIPTION} Commande préprocesseur @{"@APPTITLE Cmde préprocesseur " LINK atAPPTITLE} Commande préprocesseur @{"@APPVERSION Cmde préprocesseur " LINK atAPPVERSION} Commande préprocesseur @{"Applets " LINK Applets} Package Hollywood @{"Arc() Commande " LINK Arc} Graphisme primitif @{"ARGB() Commande " LINK ARGB} Fonction graphique @{"Information sur la couleur ARGB " LINK ARGBInfo} Fonction graphique @{"Opérateur arithmétique " LINK V6PrgOprArith} Expression et opérateur @{"ASin() Commande " LINK ASin} Fonction mathématique @{"AsyncDrawFrame() Commande " LINK AsyncDrawFrame} Fonction graphique @{"ATan() Commande " LINK ATan} Fonction mathématique @{"ATan2() Commande " LINK ATan2} Fonction mathématique @{"Auteur " LINK Credits} Qui est le créateur @{"Selection automatique d'id " LINK AutoIDSelect} Bon à savoir @{"-autoscale Argument " LINK ManualUsage} Argument de la console @{"Asc() Commande " LINK Asc} Fonction chaîne de caractère @{"-backfill Argument " LINK ManualUsage} Argument de la console @{"Fonction image de fond " LINK V6LibGfxBGPic} Description @{"BeginDoubleBuffer() Commande " LINK BeginDoubleBuffer} Fonction Double buffering @{"-bestfit Argument " LINK ManualUsage} Argument de la console @{"@BGPIC Commande préprocesseur " LINK atBGPIC} Fonction image de fond @{"%BGPIC Mots clé " LINK BGPIC} Fonction image de fond @{"BGPic introduction " LINK BGPICIntroduction} Tous se quil faut savoir sur les images de fond @{"BGPicToBrush() Commande " LINK BGPicToBrush} Fonction image de fond @{"BinStr() Commande " LINK BinStr} Fonction chaîne de caractère @{"BitClear() Commande " LINK BitClear} Fonction mathématique @{"BitComplement() Commande " LINK BitComplement} Fonction mathématique @{"BitSet() Commande " LINK BitSet} Fonction mathématique @{"BitTest() Commande " LINK BitTest} Fonction mathématique @{"Opérateur Binaire " LINK V6PrgOprBitw} Expression et opérateur @{"BitXor() Commande " LINK BitXor} Fonction mathématique @{"Block-EndBlock Déclaration " LINK V6PrgBlock} Contrôle de la programmation du flux @{"Blue() Commande " LINK Blue} Fonction graphique @{"-borderless Argument " LINK ManualUsage} Argument de la console @{"#BOTTOM Constante " LINK V6PrgInbuiltCst} Constante Hollywood @{"#BOTTOMOUT Constante " LINK V6PrgInbuiltCst} Constante Hollywood @{"Box() Commande " LINK Box} Graphisme primitif @{"Break Déclaration " LINK V6PrgBreak} Contrôle de la programmation du flux @{"BreakWhileMouseOn() Commande " LINK BreakWhileMouseOn} Compatibilité entre fonction et événement @{"@BRUSH Commande préprocesseur " LINK atBRUSH} Fonction Brosse (Brush) @{"%BRUSH Mots clé " LINK BRUSH} Fonction Brosse (Brush) @{"-brush Argument " LINK ManualUsage} Argument de la console @{"Fonction Brosse (Brush) " LINK V6LibGfxBrush} Description @{"-brushfile Argument " LINK ManualUsage} Argument de la console @{"BrushToBGPic() Commande " LINK BrushToBGPic} Fonction Brosse (Brush) @{"BrushToGray() Commande " LINK BrushToGray} Fonction Brosse (Brush) @{"%BUTTON Mots clé " LINK BUTTON} Compatibilité entre fonction et événement @{"Fonction bouton " LINK V6LibEventButton} Description @{"CancelAsyncDraw() Commande " LINK CancelAsyncDraw} Fonction graphique @{"Cast() Commande " LINK Cast} Fonction mathématique @{"Ceil() Commande " LINK Ceil} Fonction mathématique @{"#CENTER Constante " LINK V6PrgInbuiltCst} Constante Hollywood @{"ChangeDirectory() Commande " LINK ChangeDirectory} Fonction DOS @{"ChangeDisplaySize() Commande " LINK ChangeDisplaySize} Fonction Affichage @{"ChangeInterval() Commande " LINK ChangeInterval} Fonction interval @{"Constante Caractère " LINK V6PrgCaractèreCst} Variable et constante @{"CheckEvent() Commande " LINK CheckEvent} Fonction gestion des événements @{"Chr() Commande " LINK Chr} Fonction chaîne de caractère @{"Circle() Commande " LINK Circle} Graphisme primitif @{"ClearEvents() Commande " LINK ClearEvents} Compatibilité entre fonction et événement @{"ClearInterval() Commande " LINK ClearInterval} Fonction intervalle @{"ClearMove() Commande " LINK ClearMove} Fonction Calque (layer) @{"ClearTimeout() Commande " LINK ClearTimeout} Fonction gestion du temp @{"CloseCatalog() Commande " LINK CloseCatalog} Fonction localisation @{"CloseDirectory() Commande " LINK CloseDirectory} Fonction DOS @{"CloseFile() Commande " LINK CloseFile} Fonction DOS @{"CloseMusic() Commande " LINK CloseMusic} Fonction Musique @{"CLOSEWINDOW Evénement " LINK CLOSEWINDOW} Compatibilité entre fonction et événement @{"Cls() Commande " LINK Cls} Graphisme primitif @{"%CODE Mots clé " LINK CODE} Fonction programmation du flux @{"Collision() Commande " LINK Collision} Fonction graphique @{"Commentaire " LINK V6PrgComments} Les bon programmeur mettent des commentaires @{"-compile Argument " LINK ManualUsage} Argument de la console @{"Le Compilateur " LINK Compiler} Convertir votre script en exécutable @{"-compress Argument " LINK ManualUsage} Argument de la console @{"CompressFile() Commande " LINK CompressFile} Fonction DOS @{"Argument de la console " LINK ManualUsage} Démarrer Hollywood de la console @{"%CONSTANT Mots clé " LINK CONSTANT} Variable et constante @{"Const Déclaration " LINK V6PrgConst} Variable et constante @{"Constantes " LINK V6PrgConstants} Variable et constante @{"Contacte " LINK Contact} Comment contacter lauteur @{"Continue Déclaration " LINK V6PrgContinue} Contrôle de la programmation du flux @{"ConvertToBrush() Commande " LINK ConvertToBrush} Fonction Brosse (Brush) @{"Copyright " LINK Copyright} Copyright & Disclaimer @{"CopyAnim() Commande " LINK CopyAnim} Fonction animations @{"CopyBGPic() Commande " LINK CopyBGPic} Fonction image de fond @{"CopyBrush() Commande " LINK CopyBrush} Fonction Brosse (Brush) @{"CopyFile() Commande " LINK CopyFile} Fonction DOS @{"CopyMem() Commande " LINK CopyMem} Fonction bloc mémoire @{"CopySprite() Commande " LINK CopySprite} Fonction Sprite @{"CopyTextObject() Commande " LINK CopyTextObject} Fonction Texte @{"Cos() Commande " LINK Cos} Fonction mathématique @{"CRC32() Commande " LINK CRC32} Fonction DOS @{"CreateAnim() Commande " LINK CreateAnim} Fonction animations @{"CreateBGPic() Commande " LINK CreateBGPic} Fonction image de fond @{"CreateBrush() Commande " LINK CreateBrush} Fonction Brosse (Brush) @{"CreateButton() Commande " LINK CreateButton} Compatibilité entre fonction et événement @{"CreateClipRegion() Commande " LINK CreateClipRegion} Fonction graphique @{"CreateGradientBGPic() Commande " LINK CreateGradientBGPic} Fonction image de fond @{"CreateKeyDown() Commande " LINK CreateKeyDown} Compatibilité entre fonction et événement @{"CreatePointer() Commande " LINK CreatePointer} Fonction pointer de souris @{"CreateRainbowBGPic() Commande " LINK CreateGradientBGPic} Fonction image de fond @{"CreateRexxPort() Commande " LINK CreateRexxPort} Fonction ARexx @{"CreateSample() Commande " LINK CreateSample} Fonction échantillon sonore (Sample) @{"CreateSprite() Commande " LINK CreateSprite} Fonction Sprite @{"CreateTextObject() Commande " LINK CreateTextObject} Fonction graphique @{"CreateTexturedBGPic() Commande " LINK CreateTexturedBGPic} Fonction image de fond @{"Remerciement " LINK Credits} Qui est le créateur @{"CropBrush() Commande " LINK CropBrush} Fonction Brosse (Brush) @{"CtrlCQuit() Commande " LINK CtrlCQuit} Fonction dentrée utilisateur @{"Type de données " LINK V6PrgTypeIntro} Description @{"Fonction Date et Heure " LINK V6LibSysDate} Description @{"Fonction de débuggage " LINK V6LibSysDebug} Description @{"DebugOutput() Commande " LINK DebugOutput} Fonction de débuggage @{"DebugPrint() Commande " LINK DebugPrint} Fonction de débuggage @{"DebugStr() Commande " LINK DebugPrint} Fonction de débuggage @{"DebugVal() Commande " LINK DebugPrint} Fonction de débuggage @{"DecompressFile() Commande " LINK DecompressFile} Fonction DOS @{"DefineVirtualFile() Commande " LINK DefineVirtualFile} Fonction DOS @{"Deg() Commande " LINK Deg} Fonction mathématique @{"DeleteAlphaChannel() Commande " LINK DeleteAlphaChannel} Fonction Brosse (Brush) @{"DeleteButton() Commande " LINK DeleteButton} Fonction bouton @{"DeleteFile() Commande " LINK DeleteFile} Fonction DOS @{"DeleteMask() Commande " LINK DeleteMask} Fonction Brosse (Brush) @{"-depth Argument " LINK ManualUsage} Argument de la console @{"Dim Déclaration " LINK V6PrgDim} Tableau de donnée @{"DimStr Déclaration " LINK V6PrgDim} Tableau de donnée @{"@DISPLAY Commande préprocesseur " LINK atDISPLAY} Fonction Affichage @{"%DISPLAYCOLOR Mots clé " LINK DISPLAYCOLOR} Fonction Affichage @{"%DISPLAYDESKTOP Mots clé " LINK DISPLAYDESKTOP} Fonction Affichage @{"%DISPLAYSIZE Mots clé " LINK DISPLAYSIZE} Fonction Affichage @{"DisableButton() Commande " LINK DisableButton} Fonction bouton @{"DisableEvent() Commande " LINK DisableEvent} Compatibilité entre fonction et événement @{"DisableEventHandler() Commande " LINK DisableEventHandler} Compatibilité entre fonction et événement @{"DisableLayers() Commande " LINK DisableLayers} Fonction Calque (layer) @{"DisablePrecalculation() Commande " LINK DisablePrecalculation} Fonction graphique @{"Disclaimer " LINK Copyright} Copyright & Disclaimer @{"DisplayAnimFrame() Commande " LINK DisplayAnimFrame} Fonction animations @{"DisplayBGPic() Commande " LINK DisplayBGPic} Fonction image de fond @{"DisplayBGPicPart() Commande " LINK DisplayBGPicPart} Fonction image de fond @{"DisplayBGPicPartFX() Commande " LINK DisplayBGPicPartFX} Fonction image de fond @{"DisplayBrush() Commande " LINK DisplayBrush} Fonction Brosse (Brush) @{"DisplayBrushFX() Commande " LINK DisplayBrushFX} Fonction Brosse (Brush) @{"DisplayBrushPart() Commande " LINK DisplayBrushPart} Fonction Brosse (Brush) @{"DisplaySprite() Commande " LINK DisplaySprite} Fonction Sprite @{"DisplayTextObject() Commande " LINK DisplayTextObject} Fonction graphique @{"DisplayTextObjectFX() Commande " LINK DisplayTextObjectFX} Fonction graphique @{"DisplayTransitionFX() Commande " LINK DisplayTransitionFX} Fonction image de fond @{"Fonction Affichage " LINK V6LibGfxDisplay} Description @{"Distribuer votre scripts " LINK ImportantInformation} Please read this @{"Div() Commande " LINK Div} Fonction mathématique @{"DoMove() Commande " LINK DoMove} Fonction Calque (layer) @{"Fonction DOS " LINK V6LibDOSFunctions} Description @{"Fonction Double buffer " LINK V6LibGfxDoubleBuffer} Description @{"DumpMem() Commande " LINK DumpMem} Fonction bloc mémoire @{"Ellipse() Commande " LINK Ellipse} Graphisme primitif @{"EnableButton() Commande " LINK EnableButton} Fonction bouton @{"EnableEvent() Commande " LINK EnableEvent} Compatibilité entre fonction et événement @{"EnableEventHandler() Commande " LINK EnableEventHandler} Compatibilité entre fonction et événement @{"EnableLayers() Commande " LINK EnableLayers} Fonction Calque (layer) @{"EnablePrecalculation() Commande " LINK EnablePrecalculation} Fonction graphique @{"-endcolor Argument " LINK ManualUsage} Argument de la console @{"End() Commande " LINK End} Fonction programmation du flux @{"EndDoubleBuffer() Commande " LINK EndDoubleBuffer} Fonction Double buffering @{"EndSelect() Commande " LINK EndSelect} Fonction Affichage @{"Eof() Commande " LINK Eof} Fonction DOS @{"Error() Commande " LINK Error} Fonction de débuggage @{"EscapeQuit() Commande " LINK EscapeQuit} Fonction dentrée utilisateur @{"Codes d'échapement " LINK V6PrgTypeString} Information sur les codes déchapement @{"Compatibilité entre fonction et événement " LINK V6LibEventCompat} Description @{"Fonction gestion des événements " LINK V6LibEventHandler} Description @{"Librairie Event " LINK V6LibEvent} Description @{"Execute() Commande " LINK Execute} Fonction DOS @{"-exetype Argument " LINK ManualUsage} Argument de la console @{"Exists() Commande " LINK Exists} Fonction DOS @{"ExitOnError() Commande " LINK ExitOnError} Fonction de débuggage @{"Exp() Commande " LINK Exp} Fonction mathématique @{"Expression et opérateur " LINK V6PrgOpr} Description @{"F.A.Q. " LINK FAQ} Question fréquemment demandé @{"-fakefullscreen Argument " LINK ManualUsage} Argument de la console @{"False Constante " LINK V6PrgTrueFalse} Constante Hollywood @{"@FILE Commande préprocesseur " LINK atFILE} Fonction DOS @{"FileLength() Commande " LINK FileLength} Fonction DOS @{"FilePart() Commande " LINK FilePart} Fonction DOS @{"FilePos() Commande " LINK FilePos} Fonction DOS @{"FileRequest() Commande " LINK FileRequest} Fonction de requête @{"FileSize() Commande " LINK FileSize} Fonction DOS @{"FillMem() Commande " LINK FillMem} Fonction bloc mémoire @{"FindStr() Commande " LINK FindStr} Fonction chaîne de caractère @{"-fixed Argument " LINK ManualUsage} Argument de la console @{"FloodFill() Commande " LINK FloodFill} Fonction Brosse (Brush) @{"Floor() Commande " LINK Floor} Fonction mathématique @{"Flip() Commande " LINK Flip} Fonction Double buffering @{"FlipBrush() Commande " LINK FlipBrush} Fonction Brosse (Brush) @{"FlipSprite() Commande " LINK FlipSprite} Fonction Sprite @{"FlushFile() Commande " LINK FlushFile} Fonction DOS @{"Fonctions Police de caractère " LINK V6LibTextFont} Description @{"For-Next Déclaration " LINK V6PrgFor} Contrôle de la programmation du flux @{"Frac() Commande " LINK Frac} Fonction mathématique @{"FreeAnim() Commande " LINK FreeAnim} Fonction animations @{"FreeBGPic() Commande " LINK FreeBGPic} Fonction image de fond @{"FreeBrush() Commande " LINK FreeBrush} Fonction Brosse (Brush) @{"FreeClipRegion() Commande " LINK FreeClipRegion} Fonction graphique @{"FreeLayers() Commande " LINK FreeLayers} Fonction Calque (layer) @{"FreeMem() Commande " LINK FreeMem} Fonction bloc mémoire @{"FreeModule() Commande " LINK FreeModule} Fonction module Protracker @{"FreePointer() Commande " LINK FreePointer} Fonction pointer de souris @{"FreeSample() Commande " LINK FreeSample} Fonction échantillon sonore (Sample) @{"FreeSprite() Commande " LINK FreeSprite} Fonction Sprite @{"FreeTextObject() Commande " LINK FreeTextObject} Fonction graphique @{"Fonction type de donnée " LINK V6PrgTypeFunc} Type de données @{"FullPath() Commande " LINK FullPath} Fonction DOS @{"-fullscreen Argument " LINK ManualUsage} Argument de la console @{"Future " LINK ToDo} Quy aura-til dans le future @{"Collecteur de donnée " LINK V6PrgGarbageCollector} Variable et constante @{"GetAnimFrame() Commande " LINK GetAnimFrame} Fonction animations @{"GetAttribute() Commande " LINK GetAttribute} Fonction graphique @{"GetCatalogString() Commande " LINK GetCatalogString} Fonction localisation @{"GetCommandLine() Commande " LINK GetCommandLine} Fonction programmation du flux @{"GetDate() Commande " LINK GetDate} Fonction Date et Heure @{"GetDateNum() Commande " LINK GetDateNum} Fonction Date et Heure @{"GetBrushLink() Commande " LINK GetBrushLink} Fonction Brosse (Brush) @{"GetErrorName() Commande " LINK GetErrorName} Fonction de débuggage @{"GetEventCode() Commande " LINK GetEventCode} Compatibilité entre fonction et événement @{"GetFileAttributes() Commande " LINK GetFileAttributes} Fonction DOS @{"GetFPSLimit() Commande " LINK GetFPSLimit} Fonction programmation du flux @{"GetLastError() Commande " LINK GetLastError} Fonction de débuggage @{"GetLayerStyle() Commande " LINK GetLayerStyle} Fonction Calque (layer) @{"GetMemoryInfo() Commande " LINK GetMemoryInfo} Fonction Système @{"GetPatternPosition() Commande " LINK GetPatternPosition} Fonction module Protracker @{"GetProgramInfo() Commande " LINK GetProgramInfo} Fonction programmation du flux @{"GetRandomFX() Commande " LINK GetRandomFX} Fonction graphique @{"GetRealColor() Commande " LINK GetRealColor} Fonction graphique @{"GetSongPosition() Commande " LINK GetSongPosition} Fonction module Protracker @{"GetTempFileName() Commande " LINK GetTempFileName} Fonction DOS @{"Comment démarrer " LINK V6PrgIntroduction} Description @{"GetTime() Commande " LINK GetTime} Fonction Date et Heure @{"GetTimer() Commande " LINK GetTimer} Fonction de mesure du temp @{"GetType() Commande " LINK GetType} Fonction programmation du flux @{"GetVersion() Commande " LINK GetVersion} Fonction programmation du flux @{"GetVolumeInfo() Commande " LINK GetVolumeInfo} Fonction DOS @{"GetVolumeName() Commande " LINK GetVolumeName} Fonction DOS @{"GetWeekday() Commande " LINK GetWeekday} Fonction Date et Heure @{"Déclaration Global " LINK V6PrgGlobal} Variable et constante @{"Variable Global " LINK V6PrgGlobals} Variable et constante @{"Gosub() Commande " LINK Gosub} Compatibilité des fonction Hollywood 1.x @{"Goto() Commande " LINK Goto} Compatibilité des fonction Hollywood 1.x @{"Librairie Graphique " LINK V6LibGfx} Description @{"Graphisme primitif " LINK V6LibGfxDraw} Description @{"Green() Commande " LINK Green} Fonction graphique @{"Interface graphique " LINK GUI} Utilisation de linterface graphique @{"HexStr() Commande " LINK HexStr} Fonction chaîne de caractère @{"HideDisplay() Commande " LINK HideDisplay} Fonction Affichage @{"HideLayer() Commande " LINK HideLayer} Fonction Calque (layer) @{"HideLayerFX() Commande " LINK HideLayerFX} Fonction Calque (layer) @{"HidePointer() Commande " LINK HidePointer} Fonction pointer de souris @{"-hidepointer Argument " LINK ManualUsage} Argument de la console @{"-hidetitlebar Argument " LINK ManualUsage} Argument de la console @{"Historique en ANGLAIS " LINK History} Historique d'Hollywood en Anglais @{"%HOLLYWOOD Mots clé " LINK HOLLYWOOD} Fonction programmation du flux @{"If-EndIf Déclaration " LINK V6PrgIf} Contrôle de la programmation du flux @{"IIf() Commande " LINK IIf} Fonction Système @{"INACTIVEWINDOW Evénement " LINK INACTIVEWINDOW} Compatibilité entre fonction et événement @{"Inbuilt Constante " LINK V6PrgInbuiltCst} Variable et constante @{"@INCLUDE Commande préprocesseur " LINK atINCLUDE} Commande préprocesseur @{"Includes " LINK V6PrgIncludes} Comment démarrer @{"InKeyStr() Commande " LINK InKeyStr} Fonction dentrée utilisateur @{"Fonction intervalle " LINK V6LibEventInterval} Description @{"InsertItem() Commande " LINK InsertItem} Fonction Liste @{"InsertLayer() Commande " LINK InsertLayer} Fonction Calque (layer) @{"InstallEventHandler() Commande " LINK InstallEventHandler} Fonction gestion des événements @{"Int() Commande " LINK Int} Fonction mathématique @{"InvertAlphaChannel() Commande " LINK InvertAlphaChannel} Fonction Brosse (Brush) @{"InvertBrush() Commande " LINK InvertBrush} Fonction Brosse (Brush) @{"InvertMask() Commande " LINK InvertMask} Fonction Brosse (Brush) @{"IsAnim() Commande " LINK IsAnim} Fonction animations @{"IsDirectory() Commande " LINK IsDirectory} Fonction DOS @{"IsKeyDown() Commande " LINK IsKeyDown} Fonction dentrée utilisateur @{"IsLeftMouse() Commande " LINK IsLeftMouse} Fonction dentrée utilisateur @{"IsModule() Commande " LINK IsModule} Fonction module Protracker @{"IsMusic() Commande " LINK IsMusic} Fonction Musique @{"IsPicture() Commande " LINK IsPicture} Fonction graphique @{"IsRightMouse() Commande " LINK IsRightMouse} Fonction dentrée utilisateur @{"IsSample() Commande " LINK IsSample} Fonction échantillon sonore (Sample) @{"IsSamplePlaying() Commande " LINK IsSamplePlaying} Fonction échantillon sonore (Sample) @{"IsSound() Commande " LINK IsSound} Fonction son @{"JoyDir() Commande " LINK JoyDir} Fonction dentrée utilisateur @{"JoyFire() Commande " LINK JoyFire} Fonction dentrée utilisateur @{"%KEYDOWN Mots clé " LINK KEYDOWN} Compatibilité entre fonction et événement @{"Label() Commande " LINK Label} Compatibilité des fonction Hollywood 1.x @{"Fonction Calque (layer) " LINK V6LibGfxLayer} Description @{"Introduction au calque (layer) " LINK LayersIntroduction} Tous se quil faut savoir sur les calques (Layers) @{"-layerscale Argument " LINK ManualUsage} Argument de la console @{"Ld() Commande " LINK Ld} Fonction mathématique @{"#LEFT Constante " LINK V6PrgInbuiltCst} Constante Hollywood @{"LeftMouseQuit() Commande " LINK LeftMouseQuit} Fonction dentrée utilisateur @{"#LEFTOUT Constante " LINK V6PrgInbuiltCst} Constante Hollywood @{"LeftStr() Commande " LINK LeftStr} Fonction chaîne de caractère @{"Limit() Commande " LINK Limit} Fonction mathématique @{"Line() Commande " LINK Line} Graphisme primitif @{"Lieur " LINK Compiler} Convertir votre scripts en exécutable @{"-linkfiles Argument " LINK ManualUsage} Argument de la console @{"Fonction Liste " LINK V6LibSysList} Description @{"ListItems() Commande " LINK ListItems} Fonction Liste @{"Ln() Commande " LINK Ln} Fonction mathématique @{"LoadAnim() Commande " LINK LoadAnim} Fonction animations @{"LoadAnimFrame() Commande " LINK LoadAnimFrame} Fonction animations @{"LoadBGPic() Commande " LINK LoadBGPic} Fonction image de fond @{"LoadBrush() Commande " LINK LoadBrush} Fonction Brosse (Brush) @{"LoadModule() Commande " LINK LoadModule} Fonction module Protracker @{"LoadSample() Commande " LINK LoadSample} Fonction échantillon sonore (Sample) @{"LoadSprite() Commande " LINK LoadSprite} Fonction Sprite @{"Déclaration Local " LINK V6PrgLocal} Variable et constante @{"Variable Local " LINK V6PrgLocals} Variable et constante @{"Fonction localisation " LINK V6LibSysLocale} Description @{"Locate() Commande " LINK Locate} Fonction graphique @{"Log() Commande " LINK Log} Fonction mathématique @{"Opérateurs Logique " LINK V6PrgOprLogic} Expression et opérateur @{"LowerStr() Commande " LINK LowerStr} Fonction chaîne de caractère @{"Mailing list " LINK MailingList} A propos dHollywood @{"MakeButton() Commande " LINK MakeButton} Fonction bouton @{"MakeDirectory() Commande " LINK MakeDirectory} Fonction DOS @{"MatchPattern() Commande " LINK MatchPattern} Fonction DOS @{"Librairie Mathématique " LINK V6LibMath} Description @{"Mask et alpha channel " LINK V6PrgG2KMaskAlpha} Bon à savoir @{"-mastervolume Argument " LINK ManualUsage} Argument de la console @{"Max() Commande " LINK Max} Fonction mathématique @{"Fonction bloc mémoire " LINK V6LibSysMemory} Description @{"MidStr() Commande " LINK MidStr} Fonction chaîne de caractère @{"Min() Commande " LINK Min} Fonction mathématique @{"MixBrush() Commande " LINK MixBrush} Fonction Brosse (Brush) @{"MixRGB() Commande " LINK MixRGB} Fonction graphique @{"Mod() Commande " LINK Mod} Fonction mathématique @{"-modeid Argument " LINK ManualUsage} Argument de la console @{"ModifyButton() Commande " LINK ModifyButton} Compatibilité entre fonction et événement @{"ModifyKeyDown() Commande " LINK ModifyKeyDown} Compatibilité entre fonction et événement @{"%MODULE Mots clé " LINK MODULE} Fonction module Protracker @{"Fonction pointeur de souris " LINK V6LibSysPointer} Description @{"MouseX() Commande " LINK MouseX} Fonction dentrée utilisateur @{"MouseY() Commande " LINK MouseY} Fonction dentrée utilisateur @{"MoveAnim() Commande " LINK MoveAnim} Fonction animations @{"MoveBrush() Commande " LINK MoveBrush} Fonction Brosse (Brush) @{"MoveDisplay() Commande " LINK MoveDisplay} Fonction Affichage @{"MoveLayer() Commande " LINK MoveLayer} Fonction Calque (layer) @{"MovePointer() Commande " LINK MovePointer} Fonction pointer de souris @{"MoveSprite() Commande " LINK MoveSprite} Fonction Sprite @{"MoveTextObject() Commande " LINK MoveTextObject} Fonction graphique @{"MOVEWINDOW Evénement " LINK MOVEWINDOW} Compatibilité entre fonction et événement @{"Mul() Commande " LINK Mul} Fonction mathématique @{"@MUSIC Commande préprocesseur " LINK atMUSIC} Fonction Musique @{"Fonction Musique " LINK V6LibSoundMusic} Description @{"NextDirectoryEntry() Commande " LINK NextDirectoryEntry} Fonction DOS @{"NextFrame() Commande " LINK NextFrame} Fonction Calque (layer) @{"NextItem() Commande " LINK NextItem} Fonction Liste @{"Type de donnée Nil " LINK V6PrgTypeNil} Type de données @{"-nohide Argument " LINK ManualUsage} Argument de la console @{"-nomodeswitch Argument " LINK ManualUsage} Argument de la console @{"-nosound Argument " LINK ManualUsage} Argument de la console @{"Not Opérateur " LINK V6PrgOprLogic} Opérateurs Logique @{"NPrint() Commande " LINK NPrint} Fonction graphique @{"Type de donnée nombre " LINK V6PrgTypeNumber} Type de données @{"ONBUTTONCLICK Evénement " LINK ONBUTTONCLICK} Compatibilité entre fonction et événement @{"ONBUTTONCLICKALL Evénement " LINK ONBUTTONCLICKALL} Compatibilité entre fonction et événement @{"ONBUTTONOVER Evénement " LINK ONBUTTONOVER} Compatibilité entre fonction et événement @{"ONBUTTONOVERALL Evénement " LINK ONBUTTONOVERALL} Compatibilité entre fonction et événement @{"ONBUTTONRIGHTCLICK Evénement " LINK ONBUTTONRIGHTCLICK} Compatibilité entre fonction et événement @{"ONBUTTONRIGHTCLICKALL Evénement " LINK ONBUTTONRIGHTCLICKALL} Compatibilité entre fonction et événement @{"ONJOYDOWN Evénement " LINK ONJOYDOWN} Compatibilité entre fonction et événement @{"ONJOYDOWNLEFT Evénement " LINK ONJOYDOWNLEFT} Compatibilité entre fonction et événement @{"ONJOYDOWNRIGHT Evénement " LINK ONJOYDOWNRIGHT} Compatibilité entre fonction et événement @{"ONJOYFIRE Evénement " LINK ONJOYFIRE} Compatibilité entre fonction et événement @{"ONJOYLEFT Evénement " LINK ONJOYLEFT} Compatibilité entre fonction et événement @{"ONJOYRIGHT Evénement " LINK ONJOYRIGHT} Compatibilité entre fonction et événement @{"ONJOYUP Evénement " LINK ONJOYUP} Compatibilité entre fonction et événement @{"ONJOYUPLEFT Evénement " LINK ONJOYUPLEFT} Compatibilité entre fonction et événement @{"ONJOYUPRIGHT Evénement " LINK ONJOYUPRIGHT} Compatibilité entre fonction et événement @{"ONKEYDOWN Evénement " LINK ONKEYDOWN} Compatibilité entre fonction et événement @{"ONKEYDOWNALL Evénement " LINK ONKEYDOWNALL} Compatibilité entre fonction et événement @{"OpenCatalog() Commande " LINK OpenCatalog} Fonction localisation @{"OpenDirectory() Commande " LINK OpenDirectory} Fonction DOS @{"OpenFile() Commande " LINK OpenFile} Fonction DOS @{"OpenMusic() Commande " LINK OpenMusic} Fonction Musique @{"Priorité des opérateurs " LINK V6PrgOprPri} Expression et opérateur @{"Or Opérateur " LINK V6PrgOprLogic} Opérateurs Logique @{"-overwrite Argument " LINK ManualUsage} Argument de la console @{"-ownscreen Argument " LINK ManualUsage} Argument de la console @{"PadNum() Commande " LINK PadNum} Fonction chaîne de caractère @{"PathPart() Commande " LINK PathPart} Fonction DOS @{"PathRequest() Commande " LINK PathRequest} Fonction de requête @{"PauseModule() Commande " LINK PauseModule} Fonction module Protracker @{"PauseMusic() Commande " LINK PauseMusic} Fonction Musique @{"PauseTimer() Commande " LINK PauseTimer} Fonction de mesure du temp @{"Peek() Commande " LINK Peek} Fonction bloc mémoire @{"-pictrans Argument " LINK ManualUsage} Argument de la console @{"-picxpos Argument " LINK ManualUsage} Argument de la console @{"-picypos Argument " LINK ManualUsage} Argument de la console @{"PlayAnim() Commande " LINK PlayAnim} Fonction animations @{"PlayAnimDisk() Commande " LINK PlayAnimDisk} Fonction animations @{"PlayModule() Commande " LINK PlayModule} Fonction module Protracker @{"PlayMusic() Commande " LINK PlayMusic} Fonction Musique @{"PlaySample() Commande " LINK PlaySample} Fonction échantillon sonore (Sample) @{"PlaySubsong() Commande " LINK PlaySubsong} Fonction module Protracker @{"Plot() Commande " LINK Plot} Graphisme primitif @{"Poke() Commande " LINK Poke} Fonction bloc mémoire @{"Polygon() Commande " LINK Polygon} Graphisme primitif @{"Pow() Commande " LINK Pow} Fonction mathématique @{"Print() Commande " LINK Print} Fonction graphique @{"Commande préprocesseur " LINK V6PrgPreproc} Commande préprocesseur @{"Contrôle de la programmation du flux " LINK V6PrgFlow} Description @{"Information attributs de protection " LINK ProtFlagsInfo} Fonction DOS @{"Publier vos scripts " LINK ImportantInformation} Information Important @{"-pubscreen Argument " LINK ManualUsage} Argument de la console @{"-quiet Argument " LINK ManualUsage} Argument de la console @{"Rad() Commande " LINK Rad} Fonction mathématique @{"ReadChr() Commande " LINK ReadChr} Fonction DOS @{"ReadDirectory() Commande " LINK ReadDirectory} Fonction DOS @{"ReadFloat() Commande " LINK ReadFloat} Fonction DOS @{"ReadFunction() Commande " LINK ReadFunction} Fonction DOS @{"ReadInt() Commande " LINK ReadInt} Fonction DOS @{"ReadLine() Commande " LINK ReadLine} Fonction DOS @{"ReadMem() Commande " LINK ReadMem} Fonction bloc mémoire @{"ReadPixel() Commande " LINK ReadPixel} Graphisme primitif @{"ReadShort() Commande " LINK ReadShort} Fonction DOS @{"ReadString() Commande " LINK ReadString} Fonction DOS @{"ReadTable() Commande " LINK ReadTable} Fonction DOS @{"Red() Commande " LINK Red} Fonction graphique @{"Opérateurs relationnel " LINK V6PrgOprRelat} Expression et opérateur @{"Vendre votre scripts " LINK ImportantInformation} Information Important @{"Rename() Commande " LINK Rename} Fonction DOS @{"RemoveButton() Commande " LINK RemoveButton} Compatibilité entre fonction et événement @{"RemoveItem() Commande " LINK RemoveItem} Fonction Liste @{"RemoveKeyDown() Commande " LINK RemoveKeyDown} Compatibilité entre fonction et événement @{"RemoveLayer() Commande " LINK RemoveLayer} Fonction Calque (layer) @{"RemoveLayerFX() Commande " LINK RemoveLayerFX} Fonction Calque (layer) @{"RemoveSprite() Commande " LINK RemoveSprite} Fonction Sprite @{"RemoveSprites() Commande " LINK RemoveSprites} Fonction Sprite @{"Repeat-Until Déclaration " LINK V6PrgRepeat} Contrôle de la programmation du flux @{"ReplaceColors() Commande " LINK ReplaceColors} Fonction Brosse (Brush) @{"ReplaceStr() Commande " LINK ReplaceStr} Fonction chaîne de caractère @{"Requis " LINK Requirements} Quest-ce que vous avez besoin pour exécuter Hollywood @{"Identifiant Réservé " LINK V6PrgIdentifiers} Identifiant réservé au langage @{"ResetTabs() Commande " LINK ResetTabs} Fonction graphique @{"ResumeModule() Commande " LINK ResumeModule} Fonction module Protracker @{"ResumeMusic() Commande " LINK ResumeMusic} Fonction Musique @{"ResumeTimer() Commande " LINK ResumeTimer} Fonction de mesure du temp @{"Return() Commande " LINK Return} Compatibilité des fonction Hollywood 1.x @{"Return Déclaration " LINK V6PrgReturn} Contrôle de la programmation du flux @{"RGB() Commande " LINK RGB} Fonction graphique @{"Information couleur RGB " LINK RGBInfo} Fonction graphique @{"#RIGHT Constante " LINK V6PrgInbuiltCst} Constante Hollywood @{"#RIGHTOUT Constante " LINK V6PrgInbuiltCst} Constante Hollywood @{"RightStr() Commande " LINK RightStr} Fonction chaîne de caractère @{"Rnd() Commande " LINK Rnd} Fonction mathématique @{"RndF() Commande " LINK RndF} Fonction mathématique @{"Rol() Commande " LINK Rol} Fonction mathématique @{"Ror() Commande " LINK Ror} Fonction mathématique @{"RotateBrush() Commande " LINK RotateBrush} Fonction Brosse (Brush) @{"RotateLayer() Commande " LINK RotateLayer} Fonction Calque (layer) @{"RotateTextObject() Commande " LINK RotateTextObject} Fonction graphique @{"Round() Commande " LINK Round} Fonction mathématique @{"Rt() Commande " LINK Rt} Fonction mathématique @{"Run() Commande " LINK Run} Fonction DOS @{"RunRexxScript() Commande " LINK RunRexxScript} Fonction ARexx @{"@SAMPLE Commande préprocesseur " LINK atSAMPLE} Fonction échantillon sonore (Sample) @{"%SAMPLE Mots clé " LINK SAMPLE} Fonction échantillon sonore (Sample) @{"Fonction échantillon sonore (Sample) " LINK V6LibSoundSample} Description @{"Sar() Commande " LINK Sar} Fonction mathématique @{"SaveBrush() Commande " LINK SaveBrush} Fonction Brosse (Brush) @{"SaveSnapshot() Commande " LINK SaveSnapshot} Fonction graphique @{"-scalepicture Argument " LINK ManualUsage} Argument de la console @{"-scalewidth Argument " LINK ManualUsage} Argument de la console @{"-scaleheight Argument " LINK ManualUsage} Argument de la console @{"ScaleAnim() Commande " LINK ScaleAnim} Fonction animations @{"ScaleBGPic() Commande " LINK ScaleBGPic} Fonction image de fond @{"ScaleBrush() Commande " LINK ScaleBrush} Fonction Brosse (Brush) @{"ScaleLayer() Commande " LINK ScaleLayer} Fonction Calque (layer) @{"ScaleSprite() Commande " LINK ScaleSprite} Fonction Sprite @{"ScaleTextObject() Commande " LINK ScaleTextObject} Fonction graphique @{"Information moteur de redimensionement " LINK AutoScalingInfo} Bon à savoir @{"timing du Script " LINK V6PrgG2KTiming} Bon à savoir @{"-scrwidth Argument " LINK ManualUsage} Argument de la console @{"-scrheiht Argument " LINK ManualUsage} Argument de la console @{"Seek() Commande " LINK Seek} Fonction DOS @{"SeekMusic() Commande " LINK SeekMusic} Fonction Musique @{"SelectAlphaChannel() Commande " LINK SelectAlphaChannel} Fonction Brosse (Brush) @{"SelectBGPic() Commande " LINK SelectBGPic} Fonction image de fond @{"SelectBrush() Commande " LINK SelectBrush} Fonction Brosse (Brush) @{"SelectMask() Commande " LINK SelectMask} Fonction Brosse (Brush) @{"SendRexxCommand() Commande " LINK SendRexxCommand} Fonction ARexx @{"SetAlphaIntensity() Commande " LINK SetAlphaIntensity} Fonction Brosse (Brush) @{"SetBrushTransparency() Commande " LINK SetBrushTransparency} Fonction Brosse (Brush) @{"SetClipRegion() Commande " LINK SetClipRegion} Fonction graphique @{"SetEventTimeout() Commande " LINK SetEventTimeout} Fonction gestion des événements @{"SetFileAttributes() Commande " LINK SetFileAttributes} Fonction DOS @{"SetFillStyle() Commande " LINK SetFillStyle} Graphisme primitif @{"SetFont() Commande " LINK SetFont} Fonction graphique @{"SetFontColor() Commande " LINK SetFontColor} Fonction graphique @{"SetFontStyle() Commande " LINK SetFontStyle} Fonction graphique @{"SetFormStyle() Commande " LINK SetFormStyle} Graphisme primitif @{"SetFPSLimit() Commande " LINK SetFPSLimit} Fonction programmation du flux @{"SetInterval() Commande " LINK SetInterval} Fonction interval @{"SetIOMode() Commande " LINK SetIOMode} Fonction DOS @{"SetLayerLight() Commande " LINK SetLayerTint} Fonction Calque (layer) @{"SetLayerName() Commande " LINK SetLayerName} Fonction Calque (layer) @{"SetLayerStyle() Commande " LINK SetLayerStyle} Fonction Calque (layer) @{"SetLayerTint() Commande " LINK SetLayerTint} Fonction Calque (layer) @{"SetLayerTransparency() Commande " LINK SetLayerTransparency} Fonction Calque (layer) @{"SetMargins() Commande " LINK SetMargins} Fonction graphique @{"SetMaskMode() Commande " LINK SetMaskMode} Fonction Brosse (Brush) @{"SetMasterVolume() Commande " LINK SetMasterVolume} Fonction son @{"SetMusicVolume() Commande " LINK SetMusicVolume} Fonction Musique @{"SetPanning() Commande " LINK SetPanning} Fonction échantillon sonore (Sample) @{"SetPitch() Commande " LINK SetPitch} Fonction échantillon sonore (Sample) @{"SetPointer() Commande " LINK SetPointer} Fonction pointer de souris @{"SetTimeout() Commande " LINK SetTimeout} Fonction gestion du temp @{"SetTitle() Commande " LINK SetTitle} Fonction Affichage @{"SetVarType() Commande " LINK SetVarType} Fonction programmation du flux @{"SetVolume() Commande " LINK SetVolume} Fonction échantillon sonore (Sample) @{"Sgn() Commande " LINK Sgn} Fonction mathématique @{"Shl() Commande " LINK Shl} Fonction mathématique @{"ShowDisplay() Commande " LINK ShowDisplay} Fonction Affichage @{"ShowLayer() Commande " LINK ShowLayer} Fonction Calque (layer) @{"ShowLayerFX() Commande " LINK ShowLayerFX} Fonction Calque (layer) @{"ShowPointer() Commande " LINK ShowPointer} Fonction pointer de souris @{"Shr() Commande " LINK Shr} Fonction mathématique @{"Sin() Commande " LINK Sin} Fonction mathématique @{"-sizeable Argument " LINK ManualUsage} Argument de la console @{"SIZEWINDOW Evénement " LINK SIZEWINDOW} Compatibilité entre fonction et événement @{"-smoothscale Argument " LINK ManualUsage} Argument de la console @{"Sort() Commande " LINK Sort} Fonction Système @{"librairie son " LINK V6LibSound} Description @{"SplitStr() Commande " LINK SplitStr} Fonction chaîne de caractère @{"@SPRITE Commande préprocesseur " LINK atSPRITE} Fonction Sprite @{"Fonction Sprite " LINK V6LibGfxSprite} Description @{"Introduction au Sprite " LINK SpritesIntroduction} Tous se que vous devez savoir sur les Sprites @{"Sqrt() Commande " LINK Sqrt} Fonction mathématique @{"-startcolor Argument " LINK ManualUsage} Argument de la console @{"StartTimer() Commande " LINK StartTimer} Fonction de mesure du temp @{"-stayactive Argument " LINK ManualUsage} Argument de la console @{"StopAnim() Commande " LINK StopAnim} Fonction animations @{"StopModule() Commande " LINK StopModule} Fonction module Protracker @{"StopMusic() Commande " LINK StopMusic} Fonction Musique @{"StopSample() Commande " LINK StopSample} Fonction échantillon sonore (Sample) @{"StopTimer() Commande " LINK StopTimer} Fonction de mesure du temp @{"Conversion des chaîne en nombre " LINK V6PrgStrNumConv} Getting started @{"Concaténation de chaîne " LINK V6PrgOprStrng} Expression et opérateur @{"Type de donnée chaîne " LINK V6PrgTypeString} Type de données @{"Librairie chaîne " LINK V6LibString} Description @{"StringRequest() Commande " LINK StringRequest} Fonction de requête @{"StrLen() Commande " LINK StrLen} Fonction chaîne de caractère @{"StrStr() Commande " LINK StrStr} Fonction chaîne de caractère @{"StrToArray() Commande " LINK StrToArray} Fonction chaîne de caractère @{"Suggestions sur l'écriture d'un script " LINK V6PrgStyleguideSuggestions} Comment démarrer @{"Sub() Commande " LINK Sub} Fonction mathématique @{"SwapLayers() Commande " LINK SwapLayers} Fonction Calque (layer) @{"Switch-Case Déclaration " LINK V6PrgSwitch} Contrôle de la programmation du flux @{"Librairie Système " LINK V6LibSys} Description @{"SystemRequest() Commande " LINK SystemRequest} Fonction de requête @{"Tableau de donnée " LINK V6PrgTypeTable} Type de données @{"Tan() Commande " LINK Tan} Fonction mathématique @{"Librairie Texte " LINK V6LibText} Description @{"Fonction objet texte " LINK V6LibTextObject} Description @{"Fonction affichage de texte " LINK V6LibTextRender} Description @{"TextExtent() Commande " LINK TextExtent} Fonction graphique @{"TextHeight() Commande " LINK TextHeight} Fonction graphique @{"TextOut() Commande " LINK TextOut} Fonction graphique @{"TextWidth() Commande " LINK TextWidth} Fonction graphique @{"Fonction de mesure du temp " LINK V6LibSysTimer} Description @{"Fonction gestion du temp " LINK V6LibEventTimeout} Description @{"TintBrush() Commande " LINK TintBrush} Fonction Brosse (Brush) @{"%TITLE Mots clé " LINK TITLE} Fonction Affichage @{"ToNumber() Commande " LINK ToNumber} Fonction chaîne de caractère @{"ToString() Commande " LINK ToString} Fonction chaîne de caractère @{"Tooltypes " LINK ManualUsage} Use additional features @{"#TOP Constante " LINK V6PrgInbuiltCst} Constante Hollywood @{"#TOPOUT Constante " LINK V6PrgInbuiltCst} Constante Hollywood @{"TrimStr() Commande " LINK TrimStr} Fonction chaîne de caractère @{"disfonctionnement " LINK V6PrgG2KTroubleshooting} Bon à savoir @{"True Constante " LINK V6PrgTrueFalse} Constante Hollywood @{"Tutoriel " LINK V6PrgG2KTutorial} Apprendre à écrire vos propres scritps @{"Undo() Commande " LINK Undo} Fonction Calque (layer) @{"UndoFX() Commande " LINK UndoFX} Fonction Calque (layer) @{"UnleftStr() Commande " LINK UnleftStr} Fonction chaîne de caractère @{"Unpack() Commande " LINK Unpack} Fonction Liste @{"UnrightStr() Commande " LINK UnrightStr} Fonction chaîne de caractère @{"UpperStr() Commande " LINK UpperStr} Fonction chaîne de caractère @{"-usequartz Argument " LINK ManualUsage} Argument de la console @{"-usewpa Argument " LINK ManualUsage} Argument de la console @{"Fonction d'entrée utilisateur " LINK V6LibEventInput} Description @{"Val() Commande " LINK Val} Fonction chaîne de caractère @{"Variable et constante " LINK V6PrgVariables} Description @{"@VERSION Commande préprocesseur " LINK atVERSION} Commande préprocesseur @{"Enregistreur Video " LINK VideoRecorder} Sauvegarder vos script en fichier AVI @{"-videofps Argument " LINK ManualUsage} Argument de la console @{"-videoout Argument " LINK ManualUsage} Argument de la console @{"-videopointer Argument " LINK ManualUsage} Argument de la console @{"-videoquality Argument " LINK ManualUsage} Argument de la console @{"-videostrategy Argument " LINK ManualUsage} Argument de la console @{"VWait() Commande " LINK VWait} Fonction graphique @{"Wait() Commande " LINK Wait} Fonction programmation du flux @{"WaitEvent() Commande " LINK WaitEvent} Fonction gestion des événements @{"WaitKeyDown() Commande " LINK WaitKeyDown} Fonction dentrée utilisateur @{"WaitLeftMouse() Commande " LINK WaitLeftMouse} Fonction dentrée utilisateur @{"WaitPatternPosition() Commande " LINK WaitPatternPosition} Fonction module Protracker @{"WaitRightMouse() Commande " LINK WaitRightMouse} Fonction dentrée utilisateur @{"WaitSampleEnd() Commande " LINK WaitSampleEnd} Fonction échantillon sonore (Sample) @{"WaitSongPosition() Commande " LINK WaitSongPosition} Fonction module Protracker @{"WaitTimer() Commande " LINK WaitTimer} Fonction de mesure du temp @{"Qu'est-ce que Hollywood? " LINK Introduction} Introduction @{"While-Wend Déclaration " LINK V6PrgWhile} Contrôle de la programmation du flux @{"WhileKeyDown() Commande " LINK WhileKeyDown} Compatibilité entre fonction et événement @{"WhileMouseDown() Commande " LINK WhileMouseDown} Compatibilité entre fonction et événement @{"WhileMouseOn() Commande " LINK WhileMouseOn} Compatibilité entre fonction et événement @{"WhileRightMouseDown() Commande " LINK WhileRightMouseDown} Compatibilité entre fonction et événement @{"-window Argument " LINK ManualUsage} Argument de la console @{"-wpamode Argument " LINK ManualUsage} Argument de la console @{"Wrap() Commande " LINK Wrap} Fonction mathématique @{"WriteChr() Commande " LINK WriteChr} Fonction DOS @{"WriteFloat() Commande " LINK WriteFloat} Fonction DOS @{"WriteFunction() Commande " LINK WriteFunction} Fonction DOS @{"WriteInt() Commande " LINK WriteInt} Fonction DOS @{"WriteLine() Commande " LINK WriteLine} Fonction DOS @{"WriteMem() Commande " LINK WriteMem} Fonction bloc mémoire @{"WriteShort() Commande " LINK WriteShort} Fonction DOS @{"WriteString() Commande " LINK WriteString} Fonction DOS @{"WriteTable() Commande " LINK WriteTable} Fonction DOS @ENDNODE