Wir benötigen in Haxe folgende Lib’s:

• spritesheet
• hxJson2

Falls diese nicht Installiert sind kann dies mit dem Terminal / CMD nachgeholt werden.

haxelib install spritesheet
haxelib install hxJson2

Nun legen wir ein HaXe NME Projekt an. In der nmml Datei fügen wir die beiden Lib’s hinzu.

<haxelib name="spritesheet" />
<haxelib name="hxJson2" />

In FlashDevelop können die Lib’s noch zusätzlich eingetragen werden, so funktioniert auch die Autovervollständigung.

Als nächstes erstellen wir uns ein paar MovieClips in Adobe Flash CS6 und Exportieren sie als Spritesheet. Ich habe einen BouncingBall und ein RedSquare erstellt. Nun selektieren wir beide MovieClips in der Bibliothek, klicken mit der rechten Maustaste drauf und wählen Sprite-Sheet erstellen… Im nächstem Bild seht ihr meine gewählten Einstellungen, wichtig ist das Datenformat JSON-Array. Ein anderes Format habe ich bisher noch nicht umgesetzt.

Der Importer “CS6jsonArray”

Den Importer  findet ihr unter spritesheet.importers.CS6jsonArray, angelehnt an den  com.eclecticdesignstudio.spritesheet.importers.SpriteLoq. Übergeben wird die JSON Datei, das Verzeichnis der PNG Datei und den Namen des Sprites. Die letzten beiden Parameter sind optional.

Zum Namen des Sprites:
Der Name wird automatisch von CS6 gesetzt. Wird der MovieClip aus der Bibliothek exportiert, so ist es der Name aus der Bibliothek. Von der Bühne aus wir der Instanzname genutzt, falls dieser gesetzt wurde.

Somit ergibt sich für unser Beispiel der folgende Aufruf

CS6jsonArray.parse(ApplicationMain.getAsset('assets/spritesheets.json'), 'assets', 'RedSquare')

Die Funktion liefert uns ein SpriteSheet, den müssen wir dem AnimatedSprite übergeben. Im CS6jsonArry Importer habe ich die Framerate auf 30 und den Loop auf true gesetzt. Dieses Verhalten trägt den Namen sprite , da die JSON Datei keine brauchbaren Informationen liefert.

Ausschnitt der Main.hx

...
	public function new() {
		super();

		// RedQuare aus spritesheets.png erstellen, wir übergeben die JSON Datei
		var spritesheet:SpriteSheet = CS6jsonArray.parse(ApplicationMain.getAsset('assets/spritesheets.json'), 'assets', 'RedSquare');
		_square = new AnimatedSprite(spritesheet);
		_square.showBehavior('sprite');
		_square.x = 10;
		_square.y = 10;
		addChild(_square);

		// BouncingBall aus pritesheets.png erstellen
		spritesheet = CS6jsonArray.parse(ApplicationMain.getAsset('assets/spritesheets.json'), 'assets', 'BouncingBall');
		_ball = new AnimatedSprite(spritesheet);
		_ball.showBehavior('sprite');
		_ball.x = 130;
		_ball.y = 10;
		addChild(_ball);

		// Ebenfalls das RedQuare aber exportiert in einer eigenen Datei
		spritesheet = CS6jsonArray.parse(ApplicationMain.getAsset('assets/square.json'), 'assets');
		_singleSquare = new AnimatedSprite(spritesheet);
		_singleSquare.showBehavior('sprite');
		_singleSquare.x = 200;
		_singleSquare.y = 10;
		addChild(_singleSquare);

		// AnimatedSprites brauchen ein uptate
		_lastTime = Lib.getTimer();
		addEventListener(Event.ENTER_FRAME, update);
	}
...
private function update(event:Event):Void {
		var currentTime:Int = Lib.getTimer();
		var deltaTime:Int = currentTime - _lastTime;
		_square.update(deltaTime);
		_ball.update(deltaTime);
		_singleSquare.update(deltaTime);
		_lastTime = currentTime;
	}...

Der Importer

class CS6jsonArray
{

	public static function parse(data:String, assetDirectory:String="", name:String=""):SpriteSheet
	{
		var json:Dynamic = JSON.parse(data);

		var frames:Array = new Array();
		var behaviors:Hash = new Hash();
		var behaviorFrames:Array = new Array();

		if (name == "") name = json.frames[0].filename;

		var cnt:Int = 0;
		for (i in 0...json.frames.length) {
			if (name == json.frames[0].filename || 0 == json.frames[i].filename.indexOf(name))
			{
				frames.push(new SpriteSheetFrame(Std.parseInt(json.frames[i].frame.x), Std.parseInt(json.frames[i].frame.y), Std.parseInt(json.frames[i].frame.w), Std.parseInt(json.frames[i].frame.h), Std.parseInt(json.frames[i].spriteSourceSize.x), Std.parseInt(json.frames[i].spriteSourceSize.y)));
				behaviorFrames.push(cnt);
				cnt++;
			}
		}

		var behaviorData:BehaviorData = new BehaviorData("sprite", behaviorFrames, true, 30, 0, 0);
		behaviors.set("sprite", behaviorData);

		var spritesheet:SpriteSheet = new SpriteSheet(frames, behaviors);
		spritesheet.name = name;
		spritesheet.setImage(ApplicationMain.getAsset(assetDirectory + '/' + json.meta.image));
		return spritesheet;
	}

}

Und so sieht es dann aus:

Das Beispielprojekt gibt es hier: HaxeSpritesheets

Thanks Joshua Granick : http://www.joshuagranick.com/blog/2011/08/27/export-swf-animation-to-nme-using-sprite-sheets/

UPDATE 18.05.2012 20:33

So, jetzt habe ich auch einen Importer gebaut, der die Sterling XML aus Adobe Flash CS6 einließt. Diesem Importer kann sogar ein BehaviorData übergeben werden.

var behaviorData = new BehaviorData("sprite", [], true, 30, 0, 0); // sprite = Behavior Name, true = Loop, 30 = Framerate
FlashStarling.parse(ApplicationMain.getAsset('assets/spritesheets.xml'), 'assets', 'RedSquare', behaviorData)

Der Importer FlashStarling.hx

package spritesheet.importers;

import nme.display.Bitmap;
import com.eclecticdesignstudio.spritesheet.data.SpriteSheetFrame;
import com.eclecticdesignstudio.spritesheet.SpriteSheet;
import com.eclecticdesignstudio.spritesheet.data.BehaviorData;
import haxe.xml.Fast;

class FlashStarling {

	public static function parse (data:String, assetDirectory:String="", name:String="", behaviorData:BehaviorData=null):SpriteSheet {
		var frames:Array = new Array();
		var behaviors:Hash = new Hash();
		var behaviorFrames:Array = new Array();

		var xml:Xml = Xml.parse(data);
		var spriteSheetNode:Xml = xml.firstElement();

		var filename:String = new Fast(spriteSheetNode).att.imagePath;

		var cnt:Int = 0;
		for (node in spriteSheetNode.elements())
		{
			var n:Fast = new Fast(node);

			if (name == "" || 0 == n.att.name.indexOf(name))
			{
				var frameX:Int = n.has.frameX ? Std.parseInt(n.att.frameX) : 0;
				var frameY:Int = n.has.frameY ? Std.parseInt(n.att.frameY) : 0;
				frames.push(new SpriteSheetFrame(Std.parseInt(n.att.x), Std.parseInt(n.att.y), Std.parseInt(n.att.width), Std.parseInt(n.att.height), frameX, frameY));
				behaviorFrames.push(cnt);
				cnt++;
			}
		}

		if (behaviorData == null) {
			behaviorData = new BehaviorData("sprite", behaviorFrames, true, 30, 0, 0);
		} else {
			behaviorData.frames = behaviorFrames;
		}

		behaviors.set(behaviorData.name, behaviorData);

		var spritesheet:SpriteSheet = new SpriteSheet(frames, behaviors);
		spritesheet.name = name =="" ? filename : name;
		spritesheet.setImage(ApplicationMain.getAsset(assetDirectory + '/' + filename));
		return spritesheet;
	}		

}

Erste Möglichkeit wäre eine inline Konstante, diese kann Werte wie Strings, Number und Boolean aufnehmen.

public static const DEBUG_MODE:Boolean = CONFIG::debugmode;

Dem Kompiler müssen wir anschließend die Definition übergeben.

-define+=CONFIG::debugmode,true

Es können auch Berechnungen übergeben werden. Beispiele gibt es auf der Seite von Adobe.  Desweiteren ist CONFIG nicht vorgeben, so könnte man in unserem Beispiel auch HANSWURST schreiben.

In FDT können an zwei Stellen die Argumente an den Kompiler übergeben werden, siehe Screenshots

 oder  

]]> http://www.flashdevelop.de/allgemein/conditional-compilation-und-inline.html/feed 0 http://www.flashdevelop.de/actionscript-3/aus-getpixel32-den-rgb-und-alpha-wert-erhalten.html http://www.flashdevelop.de/actionscript-3/aus-getpixel32-den-rgb-und-alpha-wert-erhalten.html#comments Tue, 03 Jan 2012 11:04:22 +0000 A. Khong http://www.flashdevelop.de/?p=733 Die Methode getPixel32 liefert uns ein 32 Bit Integer und repräsentiert ein Farbwert mit einem Alphakanal (ARGB).  Die einzelnen Farbwerte bekommen wir durch Bit-Manipulation heraus.

var colour:uint = 0xCC33DD66;

var A:uint = color >> 24 & 0xFF; // alpha
var R:uint = color >> 16 & 0xFF; // rot
var G:uint = color >> 8 & 0xFF;  // grün
var B:uint = color & 0xFF;       // blau

Die Methode getPixel wird gleichermaßen errechnet, nur mit ein Wert weniger.

var color:uint = 0x33DD66;
var R:uint = color >> 16 & 0xFF;
var G:uint = color >> 8  & 0xFF;
var B:uint = color & 0xFF;

// image ist ein verknüpftes Bild in der Bibliothek
var c:BitmapData = new image(0,0);

// skalieren und anzeigen
var b:Bitmap = new Bitmap(getScaledBitmapData(c, 100, 100));

// Glättung des Bildes, fall man noch mehr machen möchte (rotieren etc)
b.smoothing = true; 

addChild(b);

/**
 * Skaliert ein BitmapData-Object proportional
 * @param scale 	Das BitmapData-Object
 * @param maxWidth	maximale Breite
 * @param maxHeight	maximale Höhe
 *
 * @return 	ein neues skaliertes BitmapData-Object
 */
function getScaledBitmapData(scale:BitmapData, maxWidth:Number, maxHeight:Number):BitmapData
{
	// Skalierungsfactor berechnen
	var wt:Number = maxWidth / scale.width;
	var ht:Number = maxHeight / scale.height;

	// kleinsten Wert bestimmen, damit maxWidth oder maxHeight nicht überschritten wird
	var factor:Number = Math.min(ht, wt);

	// Matrix mit Skalierungsfaktor erstellen und ein neues BitmapData-Object erstellen
	var m:Matrix = new Matrix();
	m.scale(factor, factor);
	var bd:BitmapData = new BitmapData(scale.width * factor, scale.height * factor, false);
	bd.draw(scale, m, null, null, null, true);
	return bd;
}

Probiert es einfach aus unter http://fdt.powerflasher.com

Was wir benötigen:

1. Flex4 SDK bekommt von Adobe
2. Packager für das iPhone von Adobe
3. AntForm
4. FDT iPhone Template

Flex4 und iPhone SDK einrichten:

Das iPhone Package ist nur eine Erweiterung für das Flex SDK, daher muss zunächst das Flex 4 SDK entpackt werden. Anschließend werden die vorhandenen Dateien mit dem iPhone Package ersetzt. Ich habe mir hierzu ein eigenen Ordner angelegt und das SDK in FDT wie folgt eingetragen. Die roten Zahlen in dem Bild sind die einzelnen Schritte.

SDK hinzufügen

Hab könnte man gleich mit einem Flex4 Air Projekt anfangen, es muss lediglich das SDK mit dem iPhone Package ausgewählt werden. Mit dem pfi Compiler, der sich in dem SDK Ordner befindet lib/pfi.jar oder bin/pfi.bat, kann aus der swf eine für das iPhone lauffähige ipa Datei erstellt werden.

Das Template:

Das Template legt bei der Projekterstellung alle wichtigen Dateien und Verzeichnisse an. Die Compiler Einstellungen werden ebenfalls angepasst. Da ich FTD unter Windows benutze, ist die Beschreibung für Mac OSX entwas anders. Das Template muss zuerst in das FDT Verzeichnis entpackt werden. Bei mir befindet sich dies in den Anwendungsdaten unter Dokumente und Einstellungen, die standart Templates sollten dort zu sehen sein. Jetzt können wir FDT starten und ein neues Projekt erstellen.

Shritt 1 - 4

Schritt 5 - 6

Nun ist das Grundgerüst des Projektes erstellt.

Templatestrukur

Wichtige Hinweise der Struktur:

* assets hier könnte die Projekt FLA hinein, die assets.fla.

* src beinhaltet die Sourcen des Projektes, die Main.as wird vom ANT Build als Einstiegspunkt genommen.

* bin hier wird die SWF abgelegt. Die Bilder im Verzeichnis icons werden vom pfi zwingend benötigt. Dies sind die Icons die im Store und auf dem iPhone angezeigt werden.

* build beinhaltet die benötigten Ant Dateien. Antform wird für die Auswahl des IPA Types und die Eingabe des Passwortes benötigt. In der build.property werden ein paar Einstellungen die für das Antbuild benötigt werden eingetragen. Diese könnte wie folgt aussehen

appName = MeinAppName
dirFlexSDK  = C:/Develop/flex_sdk_4.1.0.16076_packagerforiphone_v2_win_101110
pfi = ${dirFlexSDK}/bin/pfi.bat

certificateFile = iphone_dev.p12
provisioningFile = iphone_dev.mobileprovision

flashPlayerDebug = ${dirFlexSDK}/bin/adl.exe

mxmlc=${dirFlexSDK}/bin/mxmlc.exe

addClassPaths = 'C:/Develop/greensock/bonus-all-v11/AS3'

Durch appName wird nach dem Build eine Flashdatei MeinAppName.swf im bin Ordner liegen. dirFlexSDK gibt den Ort des Flex4 SDK mit dem iPhone package an, pfi den Ort des IPA Compilers. Da ich unter Windows arbeite, bietet sich die pfi.bat an, diese kann dem pfi mehr Ressourcen gönnen. Zur Erläuterung für Mac OSX, die pfi.bat startet die lib/pfi.jar, daher könnte auch ${dirFlexSDK}/lib/pfi.jar angeben werden, es muss allerdings die build.xml angepasst werden <java jar=”${pfi}” fork=”true” failonerror=”true”> <arg value=”-package”/>…… Evtl. könnte man sich auch ein pfi.command schreiben. certificateFile und provisioningFile sind die Zertifikate von Apple. Der Rest ist euch bestimmt schon bekannt durch Apache Ant mit FlashDevelop.

* certificates hier müssen die Zertifikate hinein.

* iPhone beinhaltet die erstellte IPA Datei

* lib hier liegen die benötigten SWCs, die assets.swc

* application.xml muss laut pfi im Root Ordner liegen, hier werden Angaben zur App gemacht.

* Default.png muss auch laut pfi im Root Ordner liegen.

IPA für das iPhone erstellen:

Das Erstellen der IPA wird von Ant übernommen. Gestartet wird es wie folgt:

Compile IPA mit Ant Schritt 1

Nun wird das Ant Build ausgeführt und es wird ein Eingabefenster angezeigt.

Compile IPA mit Ant Schritt 2

1. IPA Type
2. GPU Renderdiagnose, wird nur im ipa-test oder ipa-debug berücksichtigt.
3. Das Passwort für das Zertifikat
4. Starten des pfi Comilers. Es kann einige Minuten dauern, bis das Ergebnis vorliegt.

Einen besonderen Dank möchte ich an _geo aussprechen, der mich mit seinem Beitrag Flash iPhone Entwicklung mit FlashDevelop und dem Adobe “Packager for iPhone” inspiriert hat. Dort findet ihr eine Anleitung für FlashDevelop, und viele Details zur IPA und dem Zertifikat.

Alle Details zum packanger für iPhones findet hier bei Adobe unter  http://download.macromedia.com/pub/labs/packagerforiphone/packagerforiphone_devguide.pdf

UPDATE (18. März 2011 20:34) Template Version 1.1

• ProjectTypes rausgeflogen, es wird jetzt das Standart AS3 Air benutzt
• Der Projektname wird in den Dateien () ersetzt.
• Application ID kann optional hinzugefügt werden
• Der Ordner libs wird automatisch in den buildpath eingefügt
• Eine launch Datei wird angelegt und automatisch hinzugefügt

public function intRange(val:int, min:int, max:int):int
{
	return val < min ? min : (val > max ? max : val);
}

Die Theorie:

Ein Integer besteht aus 32 Bit. Diese Bits können in Binär oder Hexadezimal sehr schön dargestellt werden.

Binär      : 11110000111100001111000011110000
Hexadezimal: 0xF0F0F0F0
Dezimal    : 4042322160

Im Binärsystem seht jede Ziffer für ein Bit. 1 bedeutet das Bit ist gesetzt und 0 nicht gesetzt. Im Hexadezimalsystem werden vier Bits in einer Ziffer dargestellt. 0x symbolisiert lediglich, dass es sich um eine Hexadezimalzahl handelt.

Folgende Bit – Operatoren werden wir benötigen:

Links schieben : <<
Rechts schieben: >>
UND verknüpfen : &
ODER verknüpfen: |
Exclusive ODER : ^
Einerkomplement: ~

Links schieben:

Anweisung in Dezimal:

var foo:int = 1<<1;

Die Variable foo hat den Wert 2 nach der Operation, es wird praktisch mal zwei genommen. Aus Binärsicht wird einfach eine 0 von RECHTS hineingeschoben.
Binäredarstellung:

0001
0010

Rechts schieben:

Anweisung in Deziemal:

var foo:int = 2>>1;

Die Variable foo hat den Wert 1 nach der Operation, es wird praktisch durch zwei geteilt. Aus Binärsicht wird einfach eine 0 von LINKS hineingeschoben.
Binäredarstellung:

0010
0001

Hätten wir 1>>1 genommen, wäre die 1 rechts rausgefallen und hätten dann 0 und nicht 0.5, da wir im Integer Bereich arbeiten.

UND verknüpfen:

Anweisung in Dezimal:

var foo:int = 3&1;

Die Variable foo hat den Wert 1 nach der Operation. Bei UND Verknüpfungen ist 1 UND 1 wahr, 1 UND 0 falsch, und 0 UND 0 ebenfalls falsch. D. h. 1&1 = 1, 1&0 = 0 und 0&0 = 0.
Binärdarstellung:

0011  // Dez: 3
0001  // Dez: 1
----
0001  // Dez: 1

ODER verknüpfen:

Anweisung in Dezimal:

var foo:int = 2|1;

Die Variable foo hat den Wert 3 nach der Operation. Im Gegensatz du der UND-Verknüpfung ist es immer wahr, sobald eins der Bits 1 ist.
Binärdarstellung:

0010  // Dez: 2
0001  // Dez: 1
----
0011  // Dez: 3

Exclusive ODER verknüpfen:

Anweisung in Dezimal:

var foo:int = 6^5;

Die Variable foo hat den Wert 3 nach der Operation. Bei exlusive ODER ist es nur wahr wenn die Bits unterschiedlich sind.
Binärdarstellung:

0110  // Dez: 6
0101  // Dez: 5
----
0011  // Dez: 3

Einerkomplement:

Anweisung in Dezimal:

var foo:int = 3&~1;

Die Variable foo hat den Wert 2 nach der Operation. Hierbei sind zwei Schritte erforderlich. Die Bits der 1 müssen zunächst invertiert werden, die 0 wird zu 1 und die 1 zu 0. Anschließend werden die invertierten Bits UND verknüpft.
Binärdarstellung:

0011  // Dez: 3
0001  // Dez: 1

0011
1110  // invertiertes 0001
----
0010  // Dez: 2

Die Praxis:

Nehmen wir an, wir müssen ein Spiel oder eine Anwendung erstellen, in dem wir verschiedenfarbige Briefumschläge haben und ein Umschlag kann eine oder mehrere Sachen beinhalten. Es gibt also grüne, blaue, gelbe und rote Umschläge und als Sache Buch, Rechnung und CD. Vielleicht gibt es auch noch intern, öffentlich, private oder geschäftlich.

Wir definieren uns in einer Klasse,  z.B. Envelope, folgende Konstanten und setzen unsere Bits. Zu dem benötigen wir noch eine Variable, die den Brieftyp beinhaltet.

public static const GREEN:uint      = 1<<0;
public static const BLUE:uint       = 1<<1;
public static const YELLOW:uint     = 1<<2;
public static const RED:uint        = 1<<3;

public static const BOOK:uint       = 1<<20;
public static const INVOICE:uint    = 1<<21;
public static const CD:uint         = 1<<22;

public static const INTERN:uint     = 1<<28;
public static const PUBLIC:uint     = 1<<29;
public static const PRIVATE:uint    = 1<<30;
public static const COMMERCIAL:uint = 1<<31;

private var _type:uint;

Das setzen der richtigen Bits übernimmt zum Glück der Computer für uns und müssen lediglich rechts schieben. Warum wir nicht einfach die Werte 1, 2,3, 4, 5…. geben, liegt daran, dass wir nicht die Zahlen vergleichen werden, sondern den Vergleich auf Bit ebene vornehmen. D. h. wenn das erste Bit von _type gesetzt ist, ist der Umschlag grün. Man könnte ihn auch grün, rot machen, in dem man das erste und das vierte Bit setzt.

Die Bits der Farben sind also wie folgt gesetzt:

0001  // GREEN
0010  // BLUE
0100  // YELLOW
1000  // RED

An diesem Beispiel sehen wir auch, was passiert, wenn wir den public static const YELLOW:uint = 3; gesagt hätten. Die Dezimalzahl 3 ist in Binär 0011 und es hieße für uns, dass der Umschlag grün und blau ist. Spätestens wenn wir den ODER und UND Operator verwenden, dürfte dies jedem klar werden.

Einen roten Umschalg zu setzen und zu testen, ob dieser eine bestimmte Farbe hat, ist an dieser Stelle nich wirklich spannend.

_type = RED;  // roter Umschlag

// auf Farbe testen
if (_type ==  RED)
{
// Umschlag ist rot
}

Bits von _type:  1000

Spannender wird es wenn wir nun einen roten Umschlag mit einem Buch haben wollen, d. h. wir müssen das vierte und fünfte Bit setzen und genau jetzt kommt unser ODER Operator ins Spiel. Mit ODER können wir die Bits setzen.

_type = RED | BOOK;

In Binär:

00001000  // RED
00010000  // BOOK
--------
00011000 // ODER verknüpft

Siehe da, wir haben im _type das Bit für RED und BOOK gesetzt. Ab jetzt können wir nicht mehr ganz so einfach auf auf RED testen, da 00011000 nicht 000010000 ist. Um auf einen Wert zu prüfen, benötigen wir den UND Operator.

if (_type&RED > 0)
{
// ist rot
}
else
{
// ist nicht rot
}

if (_type&BOOK > 0)
{
// hat Buch
}

Schauen wir uns mal die Binärzahlen an, was mit der UND verknüpfung passiert:

00011000  // BOOK|RED  Dez: 24
00001000  // RED       Dez:  4
--------
00001000  // RED       Dez: 4

Dadurch, dass man die Bits UND verknüpft, fallen alle nicht überinstimmenden Bits weg und wir bekommen als Ergebnis das UND verknüpfte oder 0, wenn dies nicht gesetzt wurde. Siehe folgendes Beispiel

00011000  // BOOK|RED  Dez: 24
00000001  //GREEN      Dez:  1
--------
00000000  //           Dez:  0

Es gibt viele verschiedene Kombinationen mit denen man prüfen kann. Möchte man wissen, ob der Umschlag überhaupt eine Farbe hat.

00011000  // BOOK|RED               Dez: 24
00001111  // GREEN|BLUE|YELLOW|RED  Dez: 15
00001000  // RED                    Dez:  4

Beide if – Anweisungen sind binär gesehen identisch

if (_type &(GREEN|BLUE|YELLOW|RED) > 0)
...

if (_type&(0xF) >0)
...

0xF ist eine Hexadezimalzahl, man könnte sie auch mit führender 0 schreiben 0x0F und ist in Binär 00001111

Merke:

Mehrere Bits werden mit ODER gesetzt und mit UND überprüft.
BIT|BIT und BIT&BIT

Wenn wir einen blauen Umschlag mit einer CD und einer Rechnung haben, wollen aber gerne die Rechnung entfernen, so müssen wir einfach den Bit für die Rechnung löschen. Gelöscht wird mit dem Einerkomplement.

_type = CD|BLUE|INVOICE;
_type &=~INVOICE; // ist das gleiche wie _type = _type&~INVOICE;

Schauen wir uns das Ganze in Binär an

11000000000000000000010  // CD|BLUE|INVOICE
01000000000000000000000  //  INVOICE
10111111111111111111111  // ~INVOICE (invertiert)

_type &=~INVOICE
11000000000000000000010  // _type
10111111111111111111111  // UND verknüpfen ~INVOICE
--------------------------------------
10000000000000000000010  // CD|BLUE

Hier sehen wir sehr schön, dass das Bit für INVOICE entfernt wurde, bzw. auf 0 gesetzt wurde.

Zum Schluss zeige ich noch wie man höhere Bits eines Bereiches löschen kann. Wir haben zum Beispiel die beiden höchsten Bits gesetzt und wollen gerne die vier höchsten Bits löschen, also müssen wir eine UND Verknüpfung durchführen, in dem die obersten Bits auf 0 gesetzt sind.

_type = BLUE|INVOICE|PRIVATE|COMMERCIAL;
_type &= 0x0FFFFFFF;

11000000001000000000000000000010  // BLUE|INVOICE|PRIVATE|COMMERCIAL
00001111111111111111111111111111  // 0x0FFFFFFF oder ~(PRIVATE|PUBLIC|INTERN|COMMERCIAL)
00000000001000000000000000000010 // BLUE|INVOICE

_type &=~(PRIVATE|PUBLIC|COMMERCIAL|INTERN) würde zum gleichen Ergebnis führen.

Merke:

Bits werden gelöscht in dem der Einerkomplement UND verknüpft wird
BIT & ~BIT

Wollt ihr zwei Typen vertauschen, also a nach b und b nach a kopieren, gelingt euch das am schnellsten ohne temporäre Variablen anzulegen, mit dem exclusive ODER.

_type1 = BLUE;
_type2 = RED;

_type1 ^= _type2;
_type2 ^= _type1;
_type1 ^= _type2;

In Binär sieht das so aus, ihr nehmt Stift und Zettel und schreibt die Binärzahlen auf und rechnet dies wie in der Theorie gezeigt aus.

TIPS:

Wenn ihr die Eins Zweiundreisig mal links schiebt (1<<32)  fängt es wieder bei 1 an, da ein Integer nur 32 Bit hat.

Das exclusive ODER tauschen funktioniert mit jedem Integer.

var a:int = 5;
var b:int = 2;

trace(a + " und " + b) // output: 5 und 2

a ^= b;
b ^= a;
a ^= b;

trace(a + " und " + b) // output: 2 und 5

Wen ihr herausfinden wollt, wie oft eine Zahl nach links geschoben wurde, müssen wir logarithmieren. Das Schieben nach links ist nichts anderes als y = 2^x, dann ist x = log₂(y).

1<<2 = 2²
1<<3 = 2³

Da in den meisten Programmiersprachen nur der logarithmus naturalis (ln) zur Verfügung steht, müssen wir diesen umrechnen. Unsere Formel lautet dem nach x = log_e(y) / log_e(2)

In ActionScript 3 ist unser natürlicher Logarithmus zur Basis e Math.log().

var x:int  = Math.log(y)/Math.log(2);

Da die Klasse Math den Math.log(2) als Konstante ausgerechnet hat, können wir uns ein wenig Rechenzeit sparen und scheiben

var x:int = Math.log(y) / Math.LN2;

Zu Beachten ist auch, dass wir in einigen Fällen Nachkommastellen haben. Das passiert, wenn wir einen ODER verknüpften Wert nehmen. Es gibt verschiedene Möglichkeiten abzurunden, da wir uns in der Bitmanipulation befinden, benutzen wir doch gleich rechts schieben. Einmal nach rechts schieben entspricht Division durch 2 mit Abrunden.

var x:int = Math.log(y) / Math.LN2 >> 0;

Das Programm gibt es bei FlashDevelop.org

Nach dem die SWC mit Add To Library dem Projekt hinzugefügt wurde, gibt es die Optionen

1. Library (inlcude referenced classs)
2. Include library (include completely)
3. External libratry (not included)

Zu Punkt 1:
Hier werden nur die Klassen importiert, die auch tatsächlich genutzt werden. Es ist nicht möglich dynamisch Klassen zu nutzen, die vorher noch nicht referenziert wurden. Habe ich zum Beispiel zwei Verlinkungen in der SWC, einmal assets.ball und assets.korb. Wenn ich nun im Code new assets.korb(); schreibe aber niemals new assets.korb(); so würde ich eine Fehlermeldung bekommen, wenn ich loaderInfo.applicationDomain.getDefinition(“assets.korb”); benutzen würde. Der Grund ist, da die Klasse zuvor nicht referenziert wurde. Nur ein import assets.korb; würde auch nicht ausreichen.

Zu Punkt 2:
Mit dieser Option wird alles aus der SWC importiert, egal ob es benutzt oder nicht benutzt wird. Hier stehen alle Klassen aus der SWC zur Verfügung.

Zu Punkt 3:
Hier wird die SWC nicht importiert und dient lediglich der Autovervollständigung. Die SWF muss zwingend vom Programm nachgeladen werden, ansonsten gibt es eine Fehlermeldung, da alle Klassen der SWC nicht vorhanden sind.