Nye klasser i Flash CS4

Kategori: Nyheder | Kommentarer (0)
Gemt: 2008-10-8 10:18


Dokumentationen til den nye Flash CS4 blev offentliggjort for et par dage siden, og nu har venlige sjæle fået lavet en liste over alle de nye klasser som er kommet til, og den kan du se her:
New Flash CS4 Classes

Langt det meste drejer sig om de mange store nye features, som eksempelvis Inverse Kinematics og har derfor været omtalt tidligere, men der er alligevel et par småting som jeg slet ikke havde hørt om:

AdjustColor
Jeg har åbenbart ikke været den eneste som synes at det var lidt besværligt at ændre saturation, hue og brightness gennem ColorMatrixFilter, for den nye AdjustColor klasse åbner nemlig op for lige præcis det, dejligt!

MouseCursor
En lille klasse hvor man kan styre hvilken af de almindelige cursorer musen skal vises som, herunder pilen, klik-hånd, træk-hånd og I-beam.
Et godt initiativ og noget som i den grad kan være med til at hæve brugervenligheden, når bare de bruges rigtigt.

ContextMenuClipboardItems
Hvis man i Flash har et tekstfelt hvor brugerne har mulighed for at markere teksten, så dukker der anden menu frem ved højrekllik end ellers, som blandt andet giver mulighed for copy og paste.
Nu er der så kommet en klasse hvor man selv kan bestemme præcis hvilke muligheder der skal være.
Egentlig har jeg lidt svært ved at se i hvilke scenarier det konkret er nyttigt, men lidt ekstra kontrol kan jo aldrig skade.

Nå, det var hvad jeg faldt over, er du faldet over noget?


Extend en klasse del 3: Funktion på funktion

Kategori: Tips og tricks | Kommentarer (0)
Gemt: 2008-02-19 14:00


Hvis din kode er struktureret fornuftigt, så kan de funktioner du selv har tilføjet til en klasse også genbruges i nye funktioner.
Så, denne gang genbruger vi vores random() funktion fra 2. del til at lave en funktion som er kritisk for ethvert spil kort, og også nyttig i andre sammenhænge, nemlig en shuffle-funktion.

Koden er super simpel, så den får næsten lov til at stå for sig selv:


public function shuffle() {
	var _temp_arr:SuperArray = new SuperArray();
	while (this.length > 0) {
		_temp_arr.push(this.random(true))
	}
	while (_temp_arr.length > 0) {
		this.push(_temp_arr.shift());
	}
}

De to ting der primært er værd at bemærke er at _temp_arr også er af SuperArray typen, hvilket gør at vi kan genbruge random() funktionen fra tidligere, hvilket sker her:

_temp_arr.push(this.random(true))

Og, selvom det jo er et meget simpelt eksempel, så viser det hvordan man med meget få linier og en masse genbrug kan tilføje lækker ny funktionalitet.

Den komplette SuperArray klasse ser nu sådan her ud:


package {
	dynamic public class SuperArray extends Array {

		public function SuperArray(... optionalArgs) {
			for each (var value:* in optionalArgs){
				this.push(value);
			}
			//trace(length);
		}

		public function random(_delete:Boolean = false):* {
			var _random:Number = Math.floor(Math.random() * this.length);
			var _obj:*;
			if(_delete) { //hvis true fjernes elementet
				_obj = this.splice(_random, 1);
			} else { //Ellers returneres det bare
				_obj = this[_random];
			}
			return _obj;
		}

		public function shuffle() {
			var _temp_arr:SuperArray = new SuperArray();
			while (this.length > 0) {
				_temp_arr.push(this.random(true))
			}
			while (_temp_arr.length > 0) {
				this.push(_temp_arr.shift());
			}
		}

	}
}

Som skrevet tidligere, så sig endelig til hvis du har en ide til noget ny funktionalitet som du mener vores SuperArray mangler.

Note: Den kode som kopierer de sorterede elementer fra _temp_arr og tilbage til hovedarrayet kan sagtens optimeres, men denne måde at gøre det på var temmeligt selvforklarende.


Extend en klasse - del 2: Returner en tilfældig

Kategori: Tips og tricks | Kommentarer (2)
Gemt: 2008-02-14 17:38


Med basen på plads er det nu tid til at lave den egentlige funktionalitet, nemlig en funktion som kan returnere et tilfældigt element fra vores SuperArray.

For at kunne få returneret et tilfældigt element, så skal vi have lidt hjælp af Math.random() funktionen.
Det er en funktion som returnerer et tilfældigt tal fra 0 til 1, og hvis vi kombinerer det med at vi ved hjælp af length kender antallet af elementer i vores SuperArray, så er det såre simpelt at vælge et tilfældigt:

Og det skal vi så have bygget ind i en funktion som på baggrund af tallet returnerer et element:


public function random():* {
	var _random:Number = Math.floor(Math.random() * this.length);
	var _obj:* = this[_random];
	return _obj;
}

Og koden som man så ville bruge i Flash, eller et andet sted, for at bruge den nye funktion i vores SuperArray kunne se sådan her ud:


import SuperArray;
var Super_arr:SuperArray = new SuperArray("kat","hest","hund");
trace(Super_arr.random()); //Viser tilfældigt kat, hest eller hund

Ingen gentagelser
Men men men, hvad nu hvis der er tale om unikke værdier og at hver værdi kun måtte eksistere én gang?

Tag for eksempel et spil kort, her skal man helst ikke kunne få returneret “Spar es” hver gang man kalder funktionen, da der kun må være en “Spar es” i spil ad gangen.
Men, det er jo ikke trods alt ikke altid at værdierne er unikke, så lad os udvide funktionen med en valgfri variabel kaldet _delete:


public function random(_delete:Boolean = false):* {
	var _random:Number = Math.floor(Math.random() * this.length);
	var _obj:*;
	if(_delete) { //hvis true fjernes elementet
		_obj = this.splice(_random, 1);
	} else { //Ellers returneres det bare
		_obj = this[_random];
	}
	return _obj;
}

Og nu kan vi så bruge klassen på følgende måde, hvor hvert dyrt kun vil blive returneret én gang:


import SuperArray;
var Super_arr:SuperArray = new SuperArray("kat","hest","hund");
trace(Super_arr.random(true));
trace(Super_arr.random(true));
trace(Super_arr.random(true));

Samlet klasse
Så, nu ser den komplette SuperArray klasse sådan her ud:


package {
	dynamic public class SuperArray extends Array {

		public function SuperArray(... optionalArgs) {
			for each (var value:* in optionalArgs){
				this.push(value);
			}
			//trace(length);
		}

		public function random(_delete:Boolean = false):* {
			var _random:Number = Math.floor(Math.random() * this.length);
			var _obj:*;
			if(_delete) { //hvis true fjernes elementet
				_obj = this.splice(_random, 1);
			} else { //Ellers returneres det bare
				_obj = this[_random];
			}
			return _obj;
		}
	}
}

I næste artikel bygger vi endnu en smule på, nemlig en funktion som også er kritisk for et spil kort.

Har du i øvrigt en ide til en funktion som du også mener vores SuperArray bør indeholde, så smid endelig en kommentar.

Update: Arg, dammit, så fik jeg trykket udgiv allerede nu så i fik to indlæg i dag, men well, så garanterer jeg ikke for at der også kommer et i morgen ;-)


Extend en klasse - del 1: Grundstrukturen til et SuperArray

Kategori: Tips og tricks | Kommentarer (0)
Gemt: 2008-02-14 16:50


En af de ting som jeg tit har brug for rundt omkring i min kode, er en funktion som kan returnere et tilfældigt element fra et array.
Så hvorfor ikke lave en ny klasse der kan hjælpe med det, og som kan være grundlag for en lille artikelserie her på omFlash?

First things first
Hovedparten af alle klasserne i ActionScript 3 kan extendes, det vil sige at man laver en ny klasse som tager udgangspunkt i en af de eksisterende.
I dette tilfælde er det oplagt at tage udgangspunkt i den eksisterende Array-klasse, sådan så man ikke skal bruge tid på at skrive logik til alle de eksisterende funktioner som eksempelvis push, pop m.fl. men kan koncentrere sig om at tilføje ny funktionalitet.

Så, derfor kunne den første skabelon se sådan ud:


package {
	dynamic public class SuperArray extends Array {
	}
}

Constructor
Alle klasser har en constructor funktion, som er den funktion der automatisk kaldes når man laver en ny instance af sin klasse.
I dette tilfælde, hvor vores nye klasse hedder SuperArray, ville koden se sådan ud:

var Super_arr:SuperArray = new SuperArray();

Constructor funktionen er altid en public function inde i klassen som hedder det samme som klassen, hvilket gør at vores klasse nu ser sådan her ud:


package {
	dynamic public class SuperArray extends Array {
		//Constructor funktion
		public function SuperArray() {
			trace("nu er jeg oprettet!");
		}
	}
}

For et array gælder der dog det specielle, at man ofte gerne vil oprette arrayet med værdier fra start, eksempelvis sådan her:

Hvis vores nye SuperArray skal have samme funktion, så skal vores constructor udvides så den også kan modtage nogle parametre, og så ser hvor klasse sådan her ud:


package {
	dynamic public class SuperArray extends Array {
		//Constructor funktion
		public function SuperArray(... optionalArgs) {
			for each (var value:* in optionalArgs){
				this.push(value);
			}
		}
	}
}

Note: Hvis du undrer dig over hvad stjernen betyder (*), så er det fordi at man ikke på forhånd kan vide hvilken type parametre der skal modtages.
Det kan være strings som i eksemplet med dyrene, men der kunne lige så godt være tale om movieclips, tal - ja, hvad som helst.

Nu har vi et SuperArray der kan præcis det samme som et standard Array - for vildt - nu er det så tid til at udvide det!

Og det gør vi i del 2 som kommer i morgen.