86 réponses à ce sujet

[ibompuis]

Xarald, le 11 October 2008 - 18:09 PM, dit :

Salut intéréssant le post, je vais mettre également une petite contribution.

Avant tout, tout n'est pas super documenté, et super bien codé. Ayant pas mal évolué depuis quelque temp, il y a quelques truc qui sont obsolète ou pas super optimisé. Je pense retravailler un peu tout prochainement au propre, mais si ca peut servir a certain, et que je puisse avoir des critique constructive, ou conseil, ce sera avec plaisir.

Si vous avez des questions sur l'utilisations de certaine classes n'hésité pas non plus.
Certaine classe utilise la TweenLite (greensok.com) qui est également joint dans mon zip

Package utils:

<b>FrameAction :</b> Un peu comme addFrameScript, permet de déclencher une fonction a une frame ou un label

<b>Grid :</b> Pour créer des grille de clip, en ligne ou colonne (pratique pour les galerie photo)


<b>VideoFMS :</b> Pour lire une vidéo FMS et seeker dedans

Voilou, en espérant que ca servira a certain

Bonjour Xarald,

J'aurais besoin de quelques explications ou examples simple pour utiliser ces 3 classes
J'ai bien vue les propriétés et méthodes mais pour mettre en oeuvre...

Merci

[la pieuvre]

salut à tous, je met une (en fait 2) petites classes pour faire un parallaxe.

alors la première ParallaxeElement qui comme son nom l'indique correspond à un element du parallaxe ça étant Sprite.
et la deuxième ParallaxeWorld qui est n'est pas un objet d'affichage mais juste une entité qui s'occupe de la "position" des éléments.

pour l'utiliser c'est pas compliqué :

import com.inkProd.display.parallaxe.*;
// facultatif

// crée un fond pour l'ecouteur de la souris
var _fond:Sprite = new Sprite();
_fond.graphics.beginFill(0xffffff);
_fond.graphics.drawRect(0,0,stage.stageWidth, stage.stageHeight);
_fond.graphics.endFill();
addChild(_fond);


// crée un cercle de couleur aléatoire
function shp():Shape {
        var _s:Shape = new Shape();
        _s.graphics.beginFill(Math.random()*0xffffff);
        _s.graphics.drawCircle(20,20,20);
        _s.graphics.endFill();
        return _s;
}

// ajoute les objets _element à la scène en fonction de la valeur de ratio
var _elements:Array = new Array();
function _reorganizedByRatio():void{
        _elements.sortOn("ratio", Array.NUMERIC);
        var finBoucle:Number = _elements.length;
        for (var i:int = 0; i < finBoucle; i++) {
                addChild(_elements[i]);
        }
}
// fin facultatif

//crée un "monde parallaxe"
var pw:ParallaxeWorld = new ParallaxeWorld();
// définie le centre de ce monde, l'endroit où quand la caméra se trouve les objet sont exactement placés comme initialement
pw.centre=new Point(512,360);


//crée un objet ParallaxeElement
var _pe:ParallaxeElement;
// en fait plusieurs
for (var i:Number = 0; i < 10; i++) {
        _pe = new ParallaxeElement();
        // donne une valeur aléatoire à ratio
        _pe.ratio=Math.random()*1.3-.2;
        //ajoute la forme à l'élément du parallaxe
        _pe.addChild(shp());
        // définie sa position
        _pe.x=Math.random()*500;
        _pe.y=Math.random()*400;
        _elements.push(_pe);
        pw.addElement(_pe);
}
_reorganizedByRatio();

// ecouteur de la souris
function _move(e:MouseEvent):void {
        // "déplace" virtuellement la caméra en la position de la souris
        pw.setCameraPos(e.stageX, e.stageY);
}



// ajoute l'écouteur
this.addEventListener(MouseEvent.MOUSE_MOVE, _move);

[la pieuvre]

ha mince il y a pas les fichiers...

Fichier(s) joint(s)

•  com.zip   6.11 Ko   279 téléchargement(s)

[jona303]

Bon, je viens rarement sur le forum, et je ne fais pas souvent de flash,
mais j'ai aussi une petite classe qui kill les displayObjects.

Ce qu'elle à en plus de la classe Child c'est qu'elle est récursive, et qu'elle tue aussi tous les displayObject enfants. Toujours pratique quand on veut vider un container (Ce qu'il me semble ne fait pas Child, et il me semble que c'est pas parce qu'on kille un displayObject que ses enfants ont laissé la place dans la mémoire)..

Je n'ai pas encore fouillé mais je reviendrai poster les classes que je ré-utilise le plus souvent

Encore merci à tous pour vos aides et contributions

Fichier(s) joint(s)

•  KillChildren.as   802 octets   158 téléchargement(s)

[çayjb]

Bonjour

une ptite classe toute bête mais qui me sert très souvent :

package
{
    import flash.display.DisplayObject;
    import flash.display.SimpleButton;
       
    public class VerySimpleButton extends SimpleButton
    {
        private var _upState:DisplayObject;
        private var _disabledState:DisplayObject;
               
        public function VerySimpleButton(upState:DisplayObject, overState:DisplayObject = null, downState:DisplayObject = null, disabledState:DisplayObject = null)
        {
            _upState = upState;
                       
            if (!overState) overState = upState;
            if (!downState) downState = overState;
            if (!disabledState) disabledState = upState;
                       
            _disabledState = disabledState;
                       
            super(upState, overState, downState, overState);
        }
               
        override public function set mouseEnabled(value:Boolean):void
        {
            upState = value ? _upState : _disabledState;
            super.mouseEnabled = value;
        }
               
        override public function get enabled():Boolean { return mouseEnabled; }
        override public function set enabled(value:Boolean):void { mouseEnabled = value; }

        public function get disabledState():DisplayObject{ return _disabledState; }
        public function set disabledState(value:DisplayObject):void
        {
            _disabledState= value;
            if(!mouseEnabled) upState = value;
        }
    }
}

Donc c'est comme SimpleButton, avec qques petites différence qui en font un VerySimpleButton (du moins par rapport à l'utilisation que j'en fais le plus souvent) :

- plus de hitTestState, c'est automatiquement la overState qui prend sa place. Ce qui veut dire que meme avec un seul argument (upState) le bouton fonctionne bien. (d'ailleur je lui ai enlevé sa valeur par défaut à null)
- a la place on peut renseigner une disabledState qui sera l'aspect du bouton quand celui-ci est désactivé.
- et donc j'ai regroupé enabled et mouseEnabled, les deux correspondent maintenant à mouseEnabled avec en plus l'affichage de disabledState.

Modifié par çayjb, 27 February 2010 - 17:58 PM.

[Meardon]

Bonjour,

Je viens également apporter ma petites contribution

Une première classe que j'ai faite pour remplacer le composant Window malheureusement absent en AS3 :

package
{
        import flash.display.Sprite;
        import flash.display.Shape;
        import flash.display.MovieClip;
        import flash.display.SimpleButton;
        import flash.events.Event;
        import flash.events.MouseEvent;
        import flash.geom.Point;
        import flash.net.SharedObject;
       
        public class Window extends Sprite
        {
                // Occurences de scène
                public var close_btn:SimpleButton;
                public var title_bar:MovieClip;
               
                // Propriétés
                private var mousePosition:Point;
               
                // Objets partagés
                protected var userSettings_so:SharedObject;
               
                public function Window()
                {
                        userSettings_so = SharedObject.getLocal("UserSettings","/");
                       
                        if (userSettings_so.data.transparentWindows == true)
                                this.alpha = 0.8;
                       
                        if (title_bar) title_bar.mouseChildren = false;
                       
                        // Suppression du bug avec le texte
                        var graph:Shape = new Shape();
                        addChild(graph);
                        var mask:Shape = new Shape();
                        addChild(mask);
                        graph.mask = mask;
                       
                        addEventListener(Event.ADDED_TO_STAGE, addedToStage);
                        addEventListener(Event.REMOVED_FROM_STAGE, removedFromStage);
                }
               
                // Ajout à la liste d'affichage
                protected function addedToStage(e:Event):void
                {
                        if (close_btn) close_btn.addEventListener(MouseEvent.CLICK, closeWindow);
                        if (title_bar) title_bar.addEventListener(MouseEvent.MOUSE_DOWN, moveWindowOn);
                        if (title_bar) title_bar.addEventListener(MouseEvent.MOUSE_UP, moveWindowOff);
                }
               
                // Suppression de la liste d'affichage
                protected function removedFromStage(e:Event):void
                {
                        if (close_btn) close_btn.removeEventListener(MouseEvent.CLICK, closeWindow);
                        if (title_bar )title_bar.removeEventListener(MouseEvent.MOUSE_DOWN, moveWindowOn);
                        if (title_bar) title_bar.removeEventListener(MouseEvent.MOUSE_UP, moveWindowOff);
                        if (title_bar) stage.removeEventListener(MouseEvent.MOUSE_MOVE, moveWindow);
                }
               
                // Fermeture de la fenêtre
                protected function closeWindow(e:MouseEvent):void
                {
                        parent.removeChild(this);
                }
               
                // Activation du déplacement de la fenêtre
                protected function moveWindowOn(e:MouseEvent):void
                {
                        stage.addEventListener(MouseEvent.MOUSE_MOVE, moveWindow);
                        mousePosition = new Point(e.localX, e.localY);
                }
               
                // Désactivation du déplacement de la fenêtre
                protected function moveWindowOff(e:MouseEvent):void
                {
                        stage.removeEventListener(MouseEvent.MOUSE_MOVE, moveWindow);
                }
               
                // Déplacement de la fenêtre
                private function moveWindow(e:MouseEvent):void
                {
                        this.x = e.stageX - mousePosition.x - title_bar.x;
                        this.y = e.stageY - mousePosition.y - title_bar.y;
                       
                        e.updateAfterEvent();
                }
        }
}

Cette deuxième petite classe permet d'animer des points de suspension (utile pour les messages d'attente) :

package net.sgnetwork.utils
{
        import flash.utils.Timer;
        import flash.events.EventDispatcher;
        import flash.events.TimerEvent;
        import flash.text.TextField;
        import flash.text.TextFormat;
       
        public class AttemptTextField extends EventDispatcher
        {
                private var isActivated:Boolean;        // indique si le défilement est activé
                private var fieldAttempt:TextField;     // Référence du TextFField
                private var textAttempt:String;         // texte ddu TextField
                private var tAttempt:Timer;                     // Timer du défilement
               
                private var velocity:int;       // Vitesse de défilement des points de suspension
                private var nbrPoints:int;      // Nombre de points de suspension
               
                public function AttemptTextField(field:TextField, velocity, nbrPoints):void
                {
                        isActivated = false;
                        this.fieldAttempt = field;
                        this.vitesse = velocity;
                        this.pointsNbr = nbrPoints;
                       
                        tAttempt = new Timer(vitesse);
                }
               
                // Fait défiler des points de suspension
                private function ttAttempt(e:TimerEvent):void
                {
                        if (tAttempt.currentCount > pointsNbr)
                        {
                                tAttempt.reset();
                                tAttempt.start();
                                fieldAttempt.text = textAttempt;
                        }
                        else
                                fieldAttempt.appendText(".")
                }
               
                // Activation du défilement
                public function activation():void
                {
                        isActivated = true;
                        textAttempt = fieldAttempt.text;
                        tAttempt.reset();
                        tAttempt.start();
                       
                        if (!tAttempt.hasEventListener(TimerEvent.TIMER))
                                tAttempt.addEventListener(TimerEvent.TIMER, ttAttempt);
                }
               
                // Désactivation du défilement
                public function deactivation():void
                {
                        isActivated = false;
                        tAttempt.stop();
                       
                        tAttempt.removeEventListener(TimerEvent.TIMER, ttAttempt);
                }
        }
}

Et voici comment faire défiler 3 points de suspensions sur un texte :

var msgAttempt:AttemptTextField = new AttemptTextField(champ_txt, 500, 3);
msgAttempt.activation();

Modifié par Meardon, 27 February 2010 - 19:03 PM.

[seb522]

Bonjour,

je débute plus ou moins dans l'utilisation des classes et de l'AS3.
Je cherche à me servir de la classe XMLLoader disponible en première page du post.

Je récupère bien mon XMLObject mais après je n'arrive pas à accéder aux informations du xml. Je suis eprsuéadé que c 'est tout con, mais quelque chose m'échappe.

Merci

mon code :

import flash.display.Sprite;
import flash.utils.*;
import classes.utils.*;

// Définition d'un intervalle pour recharger le XML en cas de modification des informations
var intervalDuration:Number = 1000;// durée des intervalles
function SetInterval() {
        var intervalId:uint = setInterval(myRepeatingFunction, intervalDuration);

}
function myRepeatingFunction():void {

        //CHARGEMENT DES DATA XML
        var monXML = new XMLLoader("xml/data.xml");
        trace(monXML); // me renvoie [object XMLLoader]
       
        trace(monXML.messages.texte); //on utilise la syntaxe pointée pour accéder aux nÅ“uds enfants d'un nÅ“ud XML
        -> Ca ne marche pas car il cherche une fonction messages dans la classe XMLLoader.
        -> Pourtant cette classe me renvoie bien un objet XML non ?
}

//LANCMENT DU PROGRAMME
SetInterval();
 

Contenu du fichier data.xml :

<?xml version='1.0' encoding='UTF-8'?>
<messages>
        <texte label='message1'>
                le texte du message 1
        </texte>
        <texte label='message2'>
                le texte du message 2
        </texte>
</messages>
 

[frrancois]

var monXML = new XMLLoader('data.xml');
monXML.addEventListener('XML_Complete',chargement)

function chargement(e:Event)
{
        var arboXML = arbo.getXML()
}
 

il faut attendre que ls XML soit chargé pour le récupérer via le get ("J'avais changé le nom de l'evenement, je sais plus c'est quoi le nom initial)

Après pour acceder aux elements, il me semble qu'il faut mettre le numero de l'index entre crochet

trace(arboXML.messages[0])

[juanpa]

Super sympas ce post ... même si pour un débutant comme moi, ça peut paraitre ardue... mais ça peut donner des pistes pour mieux comprendre cette fabuleuse plateforme Flash

merci @ tous !

[Billyben]

Bonjour, je viens apporter ma modeste pierre.

Permet de trouver les segments qui composent les contours de formes (exclusion alpha, couleurs).

les classes :
fla exemple (cs4 - Vector!):

l'exemple :

je vous renvois vers le lien ou je m'étale pour plus d'info(ça débute pas fort)

Si ça peux vous servir...

Fichier(s) joint(s)

• 
  
  - Afficher le SWF -
  
   Test Segment 2.swf   106.25 Ko   163 téléchargement(s)
•  Segment Classe.zip   7.59 Ko   206 téléchargement(s)
•  Test Segment 2.fla   1.27 Mo   183 téléchargement(s)

[la pieuvre]

Salut les mediaboxers je viens de poster 2 sources sur mon blog

l'une pour instancier facilement des classes d'un swf chargé : www.blog.ink-prod.com : BibliothequeItem

et l'autre pour passer de l'espace 3D à l'espace 2D dans la 3D native de flash sans perdre les propriétés de position et autres : www.blog.ink-prod.com : Matrix3DToMatrix

voilà bonne continuation à tous.

[alama.be]

Bien tout ça.. J'ai bien aimé les posts au niveau Sound!! étant passionné moi même de son et de AS3, je lie l'utile a l'agréable, je développe actuellement un truc sérieux au niveau traitement du son et des DSP. Du coup, ça m’intéresse.. lol

Quelqu'un connaît et maîtrise Alchemy? ou a de bonnes notions en C ou C++? Ceux qui adorent coder Hard dans le son et les super matheux sont les bienvenus parmi mes amis.. lolol. Bon, sinon, je tâcherai de contribuer également a cet élan de générosité de don de classes.. lol On n'a qu'a organiser un AS3thon..

[tibibi0508]

Bonjour tout le monde,

Je reviens enfin, après un an d'absence passé à bosser comme un forcené.
Premier pas vers ma réinsertion, je poste cette modeste contribution qui peut largement être améliorée.



Il s'agit d'une galerie (encore une) qui permet de gérer un grand nombre d'entrée. Je comptais développer une version 3D mais je ne suis pas parvenu à maitriser l'allocation des ressources (bien trop gourmand en RAM). Pour faire défiler les images, drag and slide.

Exemple

Bonne continuation à tous! ++

Fichier(s) joint(s)

•  CLASS FXTilesInfinity.rar   57.81 Ko   144 téléchargement(s)

[Monz]

Salut Tibibi,

Welcome back !

[Nataly]

tibibi, le 06 November 2010 - 19:22 PM, dit :

Comme je le disais à Monz je suis à la ramasse (trop de temps passé sans faire d'AS3). J'espère rapidement rattraper mon retard

wo, ben ça va, t'as de beaux restes

les "petites" contributions sont toutes contentes

[tibibi0508]

Nataly, le 06 November 2010 - 22:46 PM, dit :

wo, ben ça va, t'as de beaux restes

les "petites" contributions sont toutes contentes

C'est sympa de revenir après une absence car les modos sont indulgents

Merci Nataly ++

[Tekkila]

Salut Tibibi,

Content de te relire.

Je pense que ça pourra me servir cette galerie. En changeant 2-3 trucs, je pense qu'elle s'adaptera parfaitement à un projet que j'ai en cours.

Merci,

A+

Joni

[tibibi0508]

Joni, le 08 November 2010 - 09:25 AM, dit :

Salut Tibibi,

Content de te relire.

Je pense que ça pourra me servir cette galerie. En changeant 2-3 trucs, je pense qu'elle s'adaptera parfaitement à un projet que j'ai en cours.

Merci,

A+

Joni

Salut Joni Je suis ravi que ça puisse de servir Si t'as des questions hésite pas car j'ai été scandaleux sur cette source j'ai zappé les commentaires

[kamtron]

Alors ça ne date pas d'hier, je n'en suis pas l'auteur, et peut-être que les 3/4 de la communauté connaissent ou ont trouvé mieux mais..

Personnellement c'est la classe la plus usefull que j'ai trouvé dernièrement:
http://www.anttikupi...he-entire-file/

La description est dans l'url, ça permet de retourner la taille d'une image loadée bien avant que son chargement soit complet.

[marco.a13]

Bonjours,

Voici un menu vertical supplémentaire que j'ai dû développer pour palier la disparition du composant menu disponible en AS2.
Je vous demande un peu d'indulgence car je suis passé sur l'AS3 il y a peu.
Un petit dessin valant mieux qu'un long discours ...



Enfin bref, si quelque chose vous parait bizarre, c'est possible, j'essayerai de vous répondre.

Merci à vous

Marco

Enregistré au format CS4

Miniature(s) jointe(s)

• 

Fichier(s) joint(s)

•  menuXML_Marco.zip   23.79 Ko   161 téléchargement(s)

[tlecoz]

Hello All !

Je fais le ménage dans mes sources en ce moment histoire de ressusciter mon blog, et j'ai eu besoin du composant "palette de couleur / gestion du dégradé" que j'avais réalisé pour mon article sur le ProgressiveFill.

Bref, je me suis remis un peu dans le code, j'ai changé deux trois trucs histoire de le transformer en composant ultra-simple à utiliser dans l'idée de le déposer ici
(et du coup j'ai encore rien posté sur mon blog, c'est malin...)

J'ai convertis le composant en SWC dans le but de rendre le code le moins effrayant possible (avec un SWC, on ne peut pas voir le code, donc ca fait pas peur ^^)


Voila comment on l'utilise :

package
{
        import colorconfig.ColorConfigObj;
        import flash.display.Sprite;
        import flash.events.Event;
       
        /**
         * ...
         * @author tlecoz
         */
        public class Main extends Sprite
        {
               
                private var colorMc:ColorToolMc = new ColorToolMc();
                private var colorInfo:ColorConfigObj = colorMc.config;
               
                public function Main():void
                {
                        colorMc.adjustWidth(250);
                        addChild(colorMc);
                        colorInfo.addEventListener(Event.CHANGE, onColorInfoChange);
                }
                private function onColorInfoChange(e:Event):void {
                       
                        trace("color property change : " + colorInfo.currentProperty + " -> " + colorInfo[colorInfo.currentProperty]);
                }      
        }
}      
 

- Les propriétés width/height de ColorToolsMc sont désactivés.
- Il n'est pas possible de modifier la hauteur du composant, mais il est possible de modifier sa largeur via la méthode ColorToolsMc.adjustWidth(newWidth:Number);.
- La largeur du composant ne peut pas être plus petite que 230.

Toutes les informations liées au composant sont contenues dans l'objet ColorConfigObj.
Lors de chaque action de l'utilisateur au niveau du composant, les valeurs contenues dans l'objet ColorConfigObj sont mises à jours.

Tout les setter de ColorConfigObj sont bâti comme ca :

public function set color(n:uint):void {
    _color = n;
    prop = "color";
    dispatchEvent(new Event(Event.CHANGE));
}
 

La variable 'prop' contient le nom de la propriété actuellement modifié (en l'occurence 'color'.
On peut acceder à cette variable via ColorConfigObj.currentProperty.

Puisque chaque propriété modifié dans ColorConfigObj dispatch un Event.CHANGE, on peut surveiller l'activité du composant comme cela

private function onColorInfoChange(e:Event):void {
        var currentProperty:String = colorInfo.currentProperty;
        trace(colorInfo[currentProperty])
}
 

Voici toutes les propriétés accessibles depuis ColorConfigObj :

//variables liées aux couleurs unies
- color (au format 32 bit)
- color24 (au format 24 bit)
- color32 (renvoit vers color, au format 32 bit donc)
- alpha (compris entre 0 et 1)

//variables liées aux dégradés de couleurs
- colors
- ratios
- alphas
- type ("linear" ou "radial")

//variables générales
- currentProperty
- fillType ("uniColor" ou "gradientColor")


++


EDIT : Finalement, je met aussi un zip contenant le fla et les sources afin de pouvoir faire d'éventuelles modifications (moi même j'ai modifié 4-5 fois le code depuis que je l'ai posté (je viens de remettre a jour les fichiers) )

Fichier(s) joint(s)

•  ColorToolsComponent_flashdevelop_using_SWC.zip   163.2 Ko   132 téléchargement(s)
•  ColorToolsComponent_flashProject_sources.zip   929.78 Ko   104 téléchargement(s)
• 
  
  - Afficher le SWF -
  
   colorTools.swf   72.17 Ko   197 téléchargement(s)

[Galacta]

Bonsoir ,

Me je permets de mettre à votre disposition les classes de Proba / dénombrements, calcul d'aire d'un polygone et factorisation d'entier.

Ce ne sont pas des choses des plus utile, mais c'est ce que j'apprends actuellement en cours et je m'amuse à les passer en algorithme ...

Donc voilà :

 Factorisation.as   3.71 Ko   123 téléchargement(s)
 PolygoneArea.as   1.92 Ko   134 téléchargement(s)
 Probabilities.as   3.68 Ko   138 téléchargement(s)

EDIT : La factorisation de Shor dans la classe Factorisation est un essai de l'algorithme de Shor, qui nécessite normalement un ordinateur quantique, elle n'est pas fonctionnelle, et même si elle l'était, elle ne serait que très peu intéressant due en parti à la spécificité des bit non quantiques qui ne peuvent prendre qu'un état à la fois au contraire des bit quantiques.
Voilà pour l'explication

Modifié par Galacta, 08 June 2011 - 22:19 PM.

[tlecoz]

Salut Galacta !

Si tu as un peu de temps, pourrais tu mettre un exemple d'utilisation de ta classe Factorisation et de ta classe Probabilité ?

Ca a l'air interessant mais le littéraire que je suis n'a aucune idée de à quoi ça peut servir


Merci d'avance !

[Galacta]

Salut tlecoz


Pour ce qui est de la classe Factorisation : elle permet de décomposer en produit de facteur premier ( Exemple de wikipédia : 5959 = 59*101 ).

Plusieurs algorithmes de factorisation existent et sont plus ou moins rapides. J'en ai choisi deux, qui fonctionnent très bien et sont plutôt ' rapides '.

Donc :

var factorisation : Factorisation = new Factorisation();
var number : uint = 5959;
var factor : uint = factorisation.fermatfactor(number);
var secondFactor : uint = number/factor;
trace(factor+"*"+secondFactor+"="+factor*secondFactor

Il y a certainement plus ergonomique pour ce qui est des valeurs de retour des fonctions je vais regarder ce que je peux faire

Pour la classe Probabilités :

Elle permet de faire les opérations élémentaires sur les probabilités à savoir :

- Dénombrement ( nombre de possibilités )
- Calcul de factoriel ( n! )
- Variance / Espérance / Ecart relative d'un loi discrète ( via un tableau )
- Probabilités suivant une loi binomiale ( par extension une épreuve de Bernouli )
- Afficher le triangle de Pascal ( utile pour les identités remarquables par exemple )

Probabilites.factorial(5); //120
Probabilites.triangleOfPascal(5); //[1,5,10,10,5,1]

Les function de la classe Probabilites sont static pas besoin d'instancier celle ci

Voila j'espère que ça t'aide un peu

EDIT : Je crois qu'il y a eu un bug avec l'édition ... Désolé pour le double post

Modifié par Galacta, 10 June 2011 - 12:52 PM.

[tlecoz]

Merci pour ta réponse !

Autant je comprend bien à quoi sert la classe Factorisation, autant la description que tu fais de ta classe Probabilité ne me parle pas du tout...

Si tu as encore un peu de temps (et de motivation), peux tu essayer de donner un exemple d'utilisation plus explicite si c'est possible.

Merci d'avance !

[Galacta]

Disons que c'était surtout dans un cadre ludique que j'ai codé cette classe. Elle ne sert pas forcément à grand chose , elle m'a permis de fixé les notions que j'ai vu cette année en terminale sur les proba.

L'exemple le plus concret que je puisse te donner est le suivant :

On voit beaucoup de jeu en Flash ( en autre ) qui propose en cas de victoire de gagner de l'argent ( Exemple qui me vient en tête ).

On va imaginer un jeu ou tu dois obtenir 4 rois pour gagner 5 € avec une mise de 2€ pour jouer. Le jeu ( en interne ) est composé d'un Array qui contient 16 cartes ( As, Roi, Dame, Valet pour les 4 familles : Coeur, Pique, Carreaux, Trèfle ).

On peut donc calculer le nombres de mains différentes possible d'avoir :

Probabilites.countWithoutRepetition(16,4) //1820

=> Il y a donc 1820 mains différentes possibles avec un tel jeu.

On va demander au joueur de tirer 4 cartes dans le paquet de 16, on arrive donc à une loi binomiale de paramètres 16, 4 et 1/4 ( 16 cartes, 4 tirages et la proba d'avoir un roi 4/16 <=> 1/4 ) . On dira que les tirages sont indépendants du précédent et nommerons les évènements S : " Il a tiré un roi " => Succès et P : " Il n'a pas tiré un roi " => Echec

La probabilités que le joueur tire 4 roi en 4 tirages est donc une loi de Bernoulie répétée 4 fois => Loi Binomiale.

Probabilites.binomialeLaw(16,4,1/4); //0.23

=> 23% de chance d'avoir 4 rois en 4 tirages.

Maintenant on va déterminer l'espérance d'un tel jeu ( comprendre que peu espérer gagner le joueur en jouant )

On ne change pas les règles : 4 tirages et il faut 4 rois pour gagner 5€. On a donc notre variable aléatoire qui correspondant à la somme perçut à la fin du jeu qui peut prendre les sommes suivantes : 0€ ou 5€ et les probabilités qui vont avec 0€ => 1-0.23=0.77 et 5€ = 0.23

Donc :

Probabilites.esperence([-2,5],[0.77,0.23],2); // -0.38

=> Tu peux espérer ' gagner ' ~~ -0.4€, donc perdre 0.4€ sur un grand nombre de parties. Donc le jeu ne t'ai pas favorable.

Modifié par Galacta, 10 June 2011 - 16:45 PM.

[tlecoz]

WOAW !!! Merci beaucoup pour cette réponse détaillée ! C'est très clair et passionnant !


Merci !

[Nataly]

Nom d'un schtroumpf ! On fait des trucs aussi rigolos (et inutiles ) en terminale ?! Je vais peut-être me réinscrire alors…

merci aussi

[Galacta]

J'trouve ça plutôt fun personnellement . Après niveau utilité ... Tout est relatif comme dirait l'autre ...

[Galacta]

Yop,

Je me permets encore une fois de vous proposer une classe que j'ai codé ces derniers jours pour la sécurité de mon application ( sécurité contre le phishing ) :

LevenshteinAlgorithm.as, elle permet de vérifier la proximité entre deux chaines de caractères en renvoyant le nombre d'opérations à faire afin d'obtenir la String de référence (même les symboles tout ça ).

La méthode compute admet deux paramètres, une chaine " child " qui correspond à un la valeur récupérée d'un TextInput par exemple ( c'est la string que l'on compare à notre référence ). Et le param " pattern " qui est la référence.

compute renvoie un uint correspondant à la distance de Levenshtein, plus ce nombre est proche de 0 plus la similarité est grande.
Dans le cadre d'une programmation dynamique c'est intéressant car le valeur de référence ne sera jamais écrite en claire voilà voilà.

J'vous mets les deux Algorithmes dont je me sers l'un étant plus adapté à mon projet, mais si ça peut aider certains

ExtendLevenshteinAlgorithm.as permet de vérifier en plus l'ordre des caractères dans la string et d'améliorer le comportement. Il dispatch aussi un event " FAULT_SECURITY_LOGIN_ACCES " me permettant de supprimer le contenu du TextInput et de le supprimer de la liste d'affichage.

Voilà
 LevenshteinAlgorithm.as   1.45 Ko   117 téléchargement(s)
 ExtendLevenshteinAlgorithm.as   1.66 Ko   110 téléchargement(s)

[lilive]

Une petite classe permettant de "mapper" une valeur comprise dans un intervalle vers un autre intervalle:


Usage:

xAlphaMap = new MapValue(100, 200, 0.1, 0.9);
stage.addEventListener(Event.ENTER_FRAME, enterFrameHandler);
square.startDrag(true);
private function enterFrameHandler(e:Event):void {
    square.alpha = xAlphaMap.get(square.x);
}
 

L'opacité du carré varie entre 0.1 et 0.9 quand son abscisse varie entre 100 et 200.



Même chose mais l'opacité peut aller au-delà de 0.1 et 0.9 si l'abscisse dépasse les valeurs 100 ou 200:

xAlphaMap = new MapValue(100, 200, 0.1, 0.9, true);
 

Ça marche aussi si on inverse les bornes:

xAlphaMap = new MapValue(200, 100, 0.1, 0.9);
 

Et en suivant la suggestion de goabonga, j'ai mis une méthode static:

square.startDrag(true);
stage.addEventListener(Event.ENTER_FRAME, enterFrameHandler);
private function enterFrameHandler(e:Event):void {
    square.alpha = MapValue.map(square.x, 100, 200, 0.1, 0.9);
}
 

J'ai aussi ajouté la possibilité de variation continue:

xAlphaMap = new MapValue(100, 200, 0.1, 0.9, false);
stage.addEventListener(Event.ENTER_FRAME, enterFrameHandler);
square.startDrag(true);
private function enterFrameHandler(e:Event):void {
    square.alpha = xAlphaMap.ease(square.alpha, square.x, 0.02);
}
 

où 0.02 est la vitesse de variation, entre 0 et 1.




L'idée de cette classe vient de là: http://flash.mediabo...n-actionscript/

Fichier(s) joint(s)

•  map-value.zip   3.42 Ko   169 téléchargement(s)
• 
  
  - Afficher le SWF -
  
   MapValueExamples2.swf   1.58 Ko   150 téléchargement(s)
• 
  
  - Afficher le SWF -
  
   MapValueExamples1-2.swf   1.56 Ko   119 téléchargement(s)
• 
  
  - Afficher le SWF -
  
   MapValueExamples1-3.swf   1.57 Ko   126 téléchargement(s)
• 
  
  - Afficher le SWF -
  
   MapValueExamples1.swf   1.56 Ko   153 téléchargement(s)

[Skip1327246832]

Un simple merci, parce que je débute et que ça fait plaiz de voir des gars comme vous!

[fany12]

Bonjour,

Rien de plus si ce n'est dire "Bravo à tout le monde". Merci

_______________________
Cordialement,
Fany

[Galacta]

Voilà deux classes qui simplifie un peu la gestion des évènements avec un Loader | URLLoader.

Les évènements écoutés par le Loader sont stocké dans un dictionary. Lors de l'appel à la méthode unload tout les évènements écoutés sont supprimés. Pour la classe Loader, il vaut mieux préférer utiliser unloadAndStop() qui gère cela en natif ( d'où la non-surcharge de cette méthode si ce n'est pour vider le dictionary. ).

Par contre, cette méthode prend tout son intérêt dans un URLLoader, avec la méthode close. Les listeners sont eux aussi tous supprimés. ( Mais pas en natif cette fois contrairement à la classe Loader).

SmartLoader.as

package
{
import flash.display.Loader;
import flash.events.Event;
import flash.net.URLRequest;
import flash.utils.Dictionary;

/**
  * ...
  * @author Morgan
  */
public class SmartLoadder extends Loader
{
  private var _listeners : Dictionary;

  public function SmartLoadder()
  {
   super();
   _listeners = new Dictionary(true);
  }

  override public function addEventListener(type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, useWeakReference:Boolean = false):void
  {
   if (_listeners[type] == listener) {
        return
   }
   _listeners[type] = listener;
   super.contentLoaderInfo.addEventListener(type, listener, useCapture, priority, useWeakReference);
  }
  override public function removeEventListener(type:String, listener:Function, useCapture:Boolean = false):void
  {
   if (!_listeners[type] || _listeners[type] != listener) {
        return;
   }
   delete _listeners[type];
   super.contentLoaderInfo.removeEventListener(type, listener, useCapture);
  }

  override public function unload():void
  {
   try {
          super.unload();
          }catch (e:Error) {
                                                        //do what you wanna do
          }
          for (var l : String in _listeners) {
                removeEventListener(l, _listeners[l]);
           }
  }
override public function unloadAndStop(gc:Boolean = true):void
{
          for (var l : String in _listeners) {
                 delete _listeners[l];
          }
         super.unloadAndStop(gc);
}
}
}
 

L'utilisation diffère un peu de celle classique. Il ne faut pas utiliser la reférence vers le contentLoaderInfo pour ajouter le listener, la méthode addEventListener à été surchargée pour rediriger l'écouteur sur le contentLoaderInfo (voir addEventListener dans SmartLoader.as)

Exemple :

var loader : SmartLoader = new SmartLoader();
loader.addEventListener(Event.COMPLETE, onComplete); //C'est le contentLoaderInfo qui enregistre l'écouteur.
loader.load();
loader.unloadAndStop();
 

SmartURLLoader.as

package
{
import flash.net.URLLoader;
import flash.net.URLRequest;
import flash.utils.Dictionary;

/**
  * ...
  * @author Morgan
  */
public class PoolableURLLoader extends URLLoader implements Poolable
{
  private var _listeners : Dictionary;

  public function PoolableURLLoader(request:URLRequest=null)
  {
   super(request);
   _listeners = new Dictionary(true);
  }
  override public function addEventListener(type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, useWeakReference:Boolean = false):void
  {
   if (_listeners[type] == listener) {
        return
   }
   _listeners[type] = listener;
   super.addEventListener(type, listener, useCapture, priority, useWeakReference);
  }
  override public function removeEventListener(type:String, listener:Function, useCapture:Boolean = false):void
  {
   if (!_listeners[type] || _listeners[type] != listener) {
        return
   }
   delete _listeners[type];
   super.removeEventListener(type, listener, useCapture);
  }
  override public function load(request:URLRequest):void
  {
   super.load(request);
  }
  /* INTERFACE manager.pools.Poolable */

  override public function close():void
  {
   for (var l : String in _listeners) {
        removeEventListener(l, _listeners[l]);
   }
   super.close();
  }

}
}
 

[DanBo]

Euh! moi qui cherche à développer un simulateur de flux industriels abordables pour tous en termes de prix et de facilité d'utilisation (voir 1point2, arena, etc...qui plafonnent à des 6, voire 10000 euros), me v'là bien loti avec toutes ces belles choses !
Si y en a qu'on le temps, enfin, je veux dire, qui ne savent vraiment pas quoi faire, j'ai une p'tit dév à proposer.

Etant donnés plusieurs carrés sur une surface (des machines, en fait), qu'on peut relier par des fils les flux et les commandes ou E/S), qui ne sont en contact qu'avec le carré de départ et le carré d'arrivée, comment coder la chose de sorte que si je déplace un carré parmi plusieurs, tous les fils se redessinent sans toucher ou croiser les carrés, comme cela se fait avec EAGLE dans le traçage des plaque électroniques.
C'est ma sauce pour mon futur projo de simulateur.

J'ai déjà mon idée sur l'algorithme, mais j'aimerais bien voir s'il y a des approches exotiques !...et pour le fun !

Ca pourrait être l'objet d'un projo commun ?..j'ai mis ça ici, car les idées fusent sur les classes!!!

[lilive]

Salut tout le monde,

Voici une solution permettant de faire une exportation vidéo d'une animation AIR, dans le cas où les autres ne s'appliquent pas: http://forums.mediab...06#entry1152306

[Monz]

Bonjour lilive,

M'a l'air pas mal du tout ton système. Je le testerai quand j'aurai un moment.

Citation

Je suis content: Je l'ai fait !!!!

Tu veux dire : d'acheter une chapka ?

[lilive]

Bonjour Monz

Monz, le 04 November 2012 - 15:18 PM, dit :

Tu veux dire : d'acheter une chapka ?

Hahaha! (j'ai pas compris de suite!)

[lilive]

Bonjour,

Voici de quoi créer des labyrinthes de formes différentes.

Utilisation :

- Il faut d'abord créer des cellules (classe LabCell). Ce sont les unités de base du labyrinthe. L'explorateur qui parcourt le labyrinthe se déplacera de cellule en cellule. Les cellules peuvent être de formes différentes, régulières ou pas, en 2D comme en 3D.

- Il faut ensuite créer des bords (classe LabEdge). Il faut indiquer à chaque bord les cellules qui le touche avec sa méthode addCell(). En effet chaque cellule est entourée de plusieurs bords. Par exemple des cellules carrées ont 4 bords, des hexagonales en ont 6, des cubiques en ont 6 aussi, etc. Un bord peut être commun à deux cellules. Dans ce cas il sera susceptible de devenir une porte reliant ces 2 cellules.

- Il faut finalement appeler LabBuilder.createLab() en lui passant les bords en paramètres.
A partir de là le labyrinthe est créé, et on peut consulter chaque bord pour savoir s'il est un mur ou une porte. On peut également consulter chaque cellule pour connaitre ses murs, ses portes, et les cellules qu'on peut atteindre en la quittant par une porte.

Il sera souvent utile d'étendre les classes LabCell et LabEdge pour que ces objets contiennent d'autres informations. Par exemple des informations sur leur emplacement géométrique, leur aspect, etc.

Fichier(s) joint(s)

• 
  
  - Afficher le SWF -
  
   TestLabBuilder.swf   59.81 Ko   184 téléchargement(s)
•  LabGeneration.zip   238.92 Ko   171 téléchargement(s)

[dldler]

Un autre random…

Cette petite contribution s'adresse à ceux qui utilisent de façon abondante des valeurs pseudo-aléatoires et qui recherchent un peu plus de performances que le Math.random() de base.
Ce code est conçu pour générer directement un entier non signé plutôt qu'un nombre entre 0 et 1, mais tous les types sont possibles via les classes (voir plus bas).


***************************
PERFORMANCES BRUTES : le code dans votre classe
***************************
Voici la base, que vous pouvez coller dans vos propres classes :

var random_value:uint=0x65412de2;
var random_key_A:uint=0xedca9865;
var random_key_B:uint=0x123567;
// Pour initialiser la suite de façon aléatoire, utilisez le Math.random() classique
/* random_value = uint(Math.random()*0x100000000); */

// Retourne un entier non signé entre 0x0 (inclus) et 0x100000000 (non inclus)
function  random():uint
{
  return random_value=(random_key_A+=random_value&0xDD^random_value<<7)^(random_key_B+=random_value&0xBB^random_value>>4);
}

Pour obtenir un tirage aléatoire, appelez simplement la fonction random() :

var mon_random:uint=random();

Pour plus d'infos et de types, lisez ce qui concerne les classes Random et Alea.


***************************
PERFORMANCES & SOUPLESSE : une occurrence Alea  Alea.as   1.61 Ko   120 téléchargement(s)
***************************
Si vous préférez utiliser une classe, choisissez Alea. C'est un tout petit peu plus lent, mais plus propre et plus riche.
Il vous faut créer une occurrence et la stocker, puis vous appelez le type d'aléa désiré ainsi :

var alea:Alea=new Alea();

// exemples de types
var u:uint=alea.u; // un entier non signé entre 0 et 0xFFFFFFFF
var i:int=alea.i; // un entier signé entre -0x7FFFFFFF et +0x7FFFFFFF
var d:Number = alea.D; // Un nombre compris entre 0 et 1
var b:Boolean=alea.B; // Vrai ou faux ?

// fonctions pratiques :
var v:uint=alea.under(10); // un entier non signé inférieur à 10 (non inclus)
var j:int=alea.between(-10,24); // Un entier signé entre -10 (inclus) et 24 (non inclus)

***************************
SIMPLICITé : les fonctions statiques de la classe Random  Random.as   1.68 Ko   84 téléchargement(s)
***************************
Vous pouvez utiliser la classe Random plutôt qu'Alea.
Plus simple : pas besoin de stocker une occurrence, mais plus lent… on ne peut pas tout avoir.
Les noms des fonctions sont identiques (le code aussi).

var u:uint = Random.u;

***************************
QUELQUES INFOS
***************************
Ce code génère des valeurs pseudo aléatoires qui semblent équilibrées : par tranches, au nombre de bits positifs et en fréquences de bits. C'est tout ce que je peux promettre, mon niveau en stats etant au ras des paquerettes.
Aussi, si vous rencontrez une aberration, ça serait sympa de venir la signaler.

Les gains sont de 75% pour player 9, 60% pour player 10, en utilisant le code intégré ou l'occurrence de la classe Alea.
Les gains sont de 20% pour player 9 et 30% pour player 10 avec la classe Random.

Si vous avez besoin de performances brutes mais avec d'autres types que le uint, copiez la fonction adaptée dans votre code…

Une fonction d'initialisation dans les classes Alea et Random permet de modifier la valeur initiale de la suite pseudo aléatoire. Cette fonction permet de reproduire des enchaînements de valeurs.
Vous pouvez également initiliser la suite avec un : uint(Math.random()*0x100000000); pour éviter cette redondance des enchaînements si vous ne les souhaitez pas.

[archiroc]

Bonjour,

Bah ça c'est Rudement Sympa !

J'vais ptet enfin comprendre le principe et l'utilité des Classes !

MERCI les gens.

[tlecoz]

Hello

Je cherche, en vain, la source de mon composant Tree, mais tout les liens que je trouve à partir de google ou de la recherche du forum sont mort... Les fichiers existent ils encore ?

Merci d'avance !

http://forums.mediab...post__p__874725

EDIT : je l'ai retrouvé !
http://forums.mediab...__fromsearch__1