Undolibrary MatrixArray: une extension de la classe Array

di Actionscript 3.0, con lo scopo di semplificare la manipolazione di Array lineari usati come matrice n x m . MatrixArray est une extension de la classe Array d'ActionScript 3.0, avec pour objectif de simplifier la manipulation des Array utilisés comme linéaire n matrice x m. Cette classe est une partie de la bibliothèque Undolibrary (dans le paquet undolibrary.utils.MatrixArray ) que vous pouvez télécharger gratuitement la fonction via n'importe quel client de Google code SVN (Subversion) à:
svn checkout http://undolibrary.googlecode.com/svn/trunk/
Sinon, vous pouvez télécharger le fichier unique MatrixArray.as . Un exemple de l'utilisation de la matrice linéaire a été donné en Actionscript 3.0 pour les débutants: leçon n ° 2 où nous avons vu une de ses simple utilisation dans la production du jeu classique de Tic Tac Toe. ), proprio come una scacchiera. Un tableau de ce type est comparable à une zone rectangulaire ( w x h ), tout comme un échiquier. Avec cette classe, vous pouvez traiter un tableau de ce type comme une grille avec ses coordonnées x et y. Le MatrixArray J'ai utilisé, par exemple, dans le développement de toutes les icônes émotions éditeur logique pour Skype: Skypemote .

Méthodes

aggiungendo una serie di utili metodi per gestire e manipolare matrici n x m . La classe MatrixArray s'étend donc de la classe normale Array en y ajoutant un certain nombre de méthodes utiles pour gérer et manipuler matrice N x M. Pour créer une matrice n x m est suffisante pour l'utilisation:

1
2
3
4
5
/ / Classe Importanzione - si vous avez téléchargé l'ensemble de la bibliothèque de Undolibrary
/ / Sinon, vous pouvez télécharger uniquement le fichier et l'utiliser seul MatrixArray.as
utils . MatrixArray ; les importations undolibrary utils MatrixArray..;
/ /
MatrixArray = new MatrixArray ( 10 , 10 ) ; var mais: MatrixArray = new MatrixArray (10, 10);

Création de 10 x 10 matrice, comme dans l'exemple précédent, nous pouvons la manipuler avec des méthodes qui aident à faire notre travail très simple et rapide. En fait, la matrice de 10 × 10 n'est rien de plus qu'un simple tableau linéaire de 100 éléments!

Clip ()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/ **
* Restitusice une partie rectangulaire de la matrice dans la forme MatrixArray
*
* @ Param (uint) a quitté coordonnée x de la coupe
* @ Param (uint) sy coordonnées y de la coupe
* @ Param dimension cw (uint) horizontale de la coupure
* La dimension ch @ param (uint) vertical de la coupe
* @ Résultat (MatrixArray) Une nouvelle matrice x CW CH
*
* /
uint , sy : uint , cw : uint , ch : uint ) : MatrixArray clips (à gauche: uint , sy: uint , CW: uint , CH: uint ): MatrixArray

/ / Exemple
/ / Création d'un nouveau 2,2 coordonnées MatrixArray et la largeur et hauteur 5
MatrixArray = ma . clip ( 2 , 2 , 5 , 5 ) ; var NMA: MatrixArray = ma clips (2, 2, 5, 5);.

fill ()

1
2
3
4
5
6
/ **
* Remplissez le tableau avec une valeur donnée
*
La valeur * @ param (tout) d'être inclus dans la matrice
* /
) ; remplissage (v: *);

paintChar ()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/ **
* Remplit la matrice avec (seulement) tirée d'une chaîne de caractères
* Longueur égale à la taille de la matrice
*
* @ Param (chaîne) v avec le nombre de caractères pour être cartographiés
* @ Résultat (boolean) true ok, erreur de faux: longueur de la chaîne incorrecte
*
* /
string ) paintChar (v: string)

/ / Exemple

MatrixArray = new MatrixArray ( 10 , 5 ) ; var mais: MatrixArray = new MatrixArray (10, 5);
mais. paintChar (
'**********' +
'**##**##**' +
'**********' +
'**#####**' +
'**********'
);

flipH (), flipv ()

1
2
3
4
5
6
/ **
* Effectue une orizziontale réflexion (flipH) ou
* Vertical (flipv) directement sur ​​la matrice
* /
void flipH (): void
void flipv (): void

move ()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/ **
* Déplacez le contenu du tableau (soit un quart de travail) dans les quatre
* La direction d'un offeset prédéterminés
* /
int , oy : int ) : void déplacer (x: int , y: int ): void
/ /

MatrixArray = new MatrixArray ( 10 , 5 ) ; var mais: MatrixArray = new MatrixArray (10, 5);
mais. paintChar (
'**********' +
'**##**##**' +
'**********' +
'**#####**' +
'**********'
);
2 , 4 ) ; . mais se déplacent (2, 4);

/ / Sortie
## **** ** # # # #
**********
**** #####
**********
**********

peek ()

1
2
3
4
/ **
* Retourne le contenu du tableau aux coordonnées x, y
* /
: uint , y : uint ) :* peek (x: uint , y: uint ): *

poke ()

1
2
3
4
/ **
* Définit le contenu de la matrice pour les coordonnées x, y
* /
: uint , y : uint ) : void poke (x: uint , y: uint ): void

getString ()

1
2
3
4
/ **
Souvent utilisé pour le débogage * retourne le tableau comme une chaîne de nxm
* /
String getString (): cordes

Il n'y a aucun commentaire pour cet article

Laisser un commentaire

XHTML TAG PERMIS: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong> CODE D'INSERTION: 
 <pre></pre> // blocco generico <code></code> // blocco generico [cc_actionscript][/cc_actionscript] // Actionscript [cc_actionscript3][/cc_actionscript3] // Actionscript 3 [cc_css][/cc_css] // CSS Style Sheet [cc_html][/cc_html] // HTML [cc_js][/cc_js] // Javascript [cc_objc][/cc_objc] // Objective-C [cc_php][/cc_objc] // PHP [cc_sql][/cc_sql] // SQL