Here’s some (usefull i hope ) source..

I’ve made a little fps monitor for my projects (for both as3 and flex)… so, here’s some souce and some howtos about…

There are 2 classes, FPSMonitor is made for as3 (or flash) projects, the other one, FlexFPSMonitor is made expecially for use in Flex.

Usage AS3:

import it.flashfuck.debugger.FPSMonitor;
//[...]
addChild(new FPSMonitor());

Usage Flex:

// new xmlns in application tag
xmlns:debugger="it.flashfuck.debugger.*"
//then add the tag, remember to add it at the end of your app so it's appearing in front of everything

quite simple hm?
The main difference between these classes’ results is dragging. Flex one is draggable over the application stage, the other one is not draggable (just edit the code if you want to bring it away among the screen )….

Features
FPSMonitor (as the flex one) is monitoring
- OS, Player type, version, and “is debugger”
- FPS
- Memory usage (note: this parameter tells you the memory usage by ALL flash player instances you’re running, so if you’re running more than 1 player at once this value is altered!…even in 2 firefox tabs or a standalone and a browser player)

Graph:
FPSMonitor is displaying in a graph 2 values: FPS (white) and memory usage (black) (same note for this value )
Everything is blended with BlendMode.INVERT so you can see the monitor in quite every condition.

I hope you enjoy.
Download here both classes FPSMonitor.as and FlexFPSMonitor.as

….just a note: feel free to use this code anywhere, if you’re improving functionalities, adding more features or anything else please just send me a smoke signal or a pidgeon with a message so i can update the source

Questo il codice sorgente:

package{
	import flash.display.BlendMode;
	import flash.display.Sprite;
	import flash.events.AsyncErrorEvent;
	import flash.events.Event;
	import flash.events.NetStatusEvent;
	import flash.events.SecurityErrorEvent;
	import flash.geom.ColorTransform;
	import flash.media.Video;
	import flash.net.NetConnection;
	import flash.net.NetStream;
	import org.papervision3d.cameras.Camera3D;
	import org.papervision3d.core.effects.BitmapFireEffect;
	import org.papervision3d.core.effects.utils.BitmapDrawCommand;
	import org.papervision3d.core.geom.renderables.Vertex3D;
	import org.papervision3d.core.layers.BitmapEffectLayer;
	import org.papervision3d.materials.BitmapMaterial;
	import org.papervision3d.materials.VideoStreamMaterial;
	import org.papervision3d.objects.primitives.Plane;
	import org.papervision3d.render.BasicRenderEngine;
	import org.papervision3d.scenes.Scene3D;
	import org.papervision3d.view.Viewport3D;
	[SWF(width="400",height="400",frameRate="24",backgroundColor="0x111111")]
	public class Flag3D extends Sprite	{
		[Embed (source="assets/360.png")] private var FlagAsset:Class;
		private var _scene:Scene3D;
		private var _cam:Camera3D;
		private var _view:Viewport3D;
		private var _render:BasicRenderEngine;
		private var _bfx:BitmapEffectLayer;
		private var _p:Plane;
		private var _bgp:Plane;
		private var _sine:Number=0;
		private var _srcs:Array = [
		//"http://www.youtube.com/get_video?video_id=Qk1qSpM63u4&t=OEgsToPDskIHja8NsMXSksfwHJKkwY2t",
		"http://www.flashfuck.it/360/get_video.flv"
		];
		private var _conn:NetConnection;
		private var _video:Video;
		private var _stream:NetStream;

		public function Flag3D()
		{
			super();
			stage.scaleMode = "noScale";
			stage.align = "TL";
			initVideo();
			init3D();
		}

		private function initVideo():void
		{
			_video = new Video(320,240);
			connection();
			trace("init video")
		}

		private function init3D():void
		{
			trace("init 3d")
			_view = new Viewport3D(0,0,true,true,true,true);
			_view.addEventListener(Event.ADDED_TO_STAGE,onViewPortReady);
			_cam = new Camera3D();
			_cam.focus=100;
			_cam.zoom=11;
			_cam.z=-1000;
			_scene = new Scene3D();
			_render = new BasicRenderEngine();
			addChild(_view);
		}

		private function onViewPortReady(e:Event):void
		{
			addElements();
			setupEffects();
		}

		private function setupEffects():void
		{
			_bfx = new BitmapEffectLayer(_view.width,_view.height);
			_bfx.addEffect( new BitmapFireEffect(1,1,1,1) );
			_bfx.drawCommand = new BitmapDrawCommand(null,new ColorTransform(1,1,1,1),BlendMode.HARDLIGHT,true);
			_bfx.drawLayer.blendMode = BlendMode.OVERLAY;
			_view.addRenderLayer(_bfx);
			_p.material.renderLayer = _bfx;
		}

		private function addElements():void
		{
			trace("add plane");
			_p = createFlag();
			_scene.addChild(_p);
			_bgp = createBG();
			_scene.addChild(_bgp);
			startRendering();
		}

		public function startRendering():void
		{
			this.addEventListener(Event.ENTER_FRAME,render);
		}

		public function stopRendering():void
		{
			this.removeEventListener(Event.ENTER_FRAME,render);
		}

		private function createFlag():Plane
		{
			trace("plane");
			var p:Plane = new Plane(createBitmapMaterial(),200,200,5,5);
			return p;
		}

		private function createBG():Plane
		{
			trace("plane");
			var p:Plane = new Plane(createVideoMaterial(),3200,2400,5,5);
			p.z = 1800;
			return p;
		}

		private function createBitmapMaterial():BitmapMaterial
		{
			var m:BitmapMaterial = new BitmapMaterial(new FlagAsset().bitmapData);
			m.doubleSided=true;
			m.smooth=true;
			return m;
		}

		private function createVideoMaterial():VideoStreamMaterial
		{
			var m:VideoStreamMaterial = new VideoStreamMaterial(_video,_stream);
			m.smooth=true;
			m.doubleSided=true;
			return m;
		}

		private function render(e:Event=null):void
		{
			_cam.hover(1,_view.containerSprite.mouseX/400,_view.containerSprite.mouseY/400);
			_p.yaw(.2);
			_render.renderScene(_scene,_cam,_view);
			_sine++;
			tweenPlaneMesh();
		}

		private function tweenPlaneMesh():void
		{
			var _deltaZ:Number= 30;
			var count:int=0;
			//plane waving:)
			for each(var v:Vertex3D in _p.geometry.vertices){
				var _vz:Number = Math.sin((count+_sine)/10)*_deltaZ;
				v.z = _vz;
				count++;
			}
		}
		private function connection():void
		{
			_conn = new NetConnection();
			_conn.addEventListener(NetStatusEvent.NET_STATUS,netHandler);
			_conn.addEventListener(SecurityErrorEvent.SECURITY_ERROR,crossdomainHandler);
			_conn.connect(null);
		}
		private function netHandler(e:NetStatusEvent):void
		{
			switch(e.info.code){
			case "NetConnection.Connect.Success":
                    startVideo();
                break;
                case "NetStream.Play.StreamNotFound":
                    trace("404!");
           		break;
			}
		}

		private function crossdomainHandler(e:SecurityErrorEvent):void
		{
			trace("security error: "+e);
		}

		private function startVideo():void
		{
			_stream = createStream();
			_video.attachNetStream(_stream);
			_stream.play(_srcs[0]);
		}

		private function createStream():NetStream
		{
			var stream:NetStream = new NetStream(_conn);
			stream.addEventListener(AsyncErrorEvent.ASYNC_ERROR,manageAsync);
			stream.addEventListener(NetStatusEvent.NET_STATUS,netHandler);
			return stream;
		}

		private function manageAsync(e:AsyncErrorEvent):void
		{
			//nada de nada 
		}
	}
}

Download Source

Come creare un effetto “pila” o “occhio di bue”? o pi√π banalmente, come creare una maschera sfumata con flash8 o superiori?

1. crea un movieclip da mascherare
2. crea un altro movieclip contenente una forma con riempimento a gradiente nel quale almeno un colore abbia alpha minore di 100
3. posiziona nello stage (fisicamente o via actionscript) i due clip: il mascherato e la maschera
4. via actionscript imposta a true la proprietà “cacheAsBitmap” di ciascun movieclip
5. sempre via actionscript imposta la maschera del movieclip da mascherare (setMask in AS2 o mask in AS3)

ecco il risultato:
[flash http://www.flashfuck.it/wp-content/uploads/2008/01/maschere_sfumate1.swf w=400 h=200]

questo il fla dell’esempio (CS3) Download Source

In soldoni grazie al suo lavoro ora è possibile utilizzare delle transizioni 3D tra i component, gli stati, i viewstack e quant’altro con un semplice tag…AWESOME

ecco un po’ di esempi…

Zoom
[flash http://www.tink.ws/blog/files/flex/ZoomExample.swf w=400 h=300]

Cube
[flash http://www.tink.ws/blog/files/flex/CubeExample.swf w=400 h=300]

Flip
[flash http://www.tink.ws/blog/files/flex/FlipExample.swf w=400 h=300]

Rotate
[flash http://www.tink.ws/blog/files/flex/RotateExample.swf w=400 h=300]

…buon divertimento

Il breve tutorial che andrete a leggere verte su come fare un semplice drag n drop tra 2 list component in modo che gli item dell’uno fungano come target al drop degli elementi dell’altro (una possibile applicazione potrebbe essere quella di spostare dei files all’interno di una lista di cartelle).

Il drag n drop standard:

Flex permette di abilitare il drag n drop tra due component direttamente da mxml, senza tanti problemi, abilitando le proprietà dragEnabled e dropEnabled dei componenti desiderati.

Il risultato che si ottiene abilitando dragEnabled e dropEnabled è questo:

[flash http://www.flashfuck.it/wp-content/uploads/2007/11/dragdropintoko.swf w=400 h=300]

Droppando gli elementi della tilelist all’interno del datagrid questi verranno clonati ed aggiunti allo stesso datagrid. Le righe del datagrid non sono selezionabili, i nuovi elementi sono aggiunti prima o dopo i record già presenti.

Il drag n drop into:

Mi ci sono scervellato un pò, ho tirato in ballo varie community, ma alla fine la soluzione era nel langRef di flex (come al solito )

Prendiamo in considerazione la struttura dell’applicazione

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute">
<mx:HBox width="100%" height="100%">
<mx:DataGrid width="50%" height="100%" id="drop_dg">
<mx:columns>
<mx:DataGridColumn headerText="Directories" dataField="label"/>
</mx:columns>
<mx:dataProvider>
<mx:ArrayCollection>
<mx:Array>
<mx:Object label='directory 1'/>
<mx:Object label='directory 2'/>
<mx:Object label='directory 3'/>
<mx:Object label='directory 4'/>
</mx:Array>
</mx:ArrayCollection>
</mx:dataProvider>
</mx:DataGrid>
<mx:TileList width="50%"
height="100%"
labelField="label"
dragEnabled="true"
id="drag_tl"
columnWidth="50"
rowHeight="50"
allowMultipleSelection="true">
<mx:dataProvider>
<mx:ArrayCollection>
<mx:Array>
<mx:Object label='item 1'/>
<mx:Object label='item 2'/>
<mx:Object label='item 3'/>
<mx:Object label='item 4'/>
</mx:Array>
</mx:ArrayCollection>
</mx:dataProvider>
</mx:TileList>
</mx:HBox>
</mx:Application>

E’ piuttosto semplice: una HBox contenente un datagrid (drop_dg) e una tilelist (drag_tl), entrambi con il loro dataprovider, e la tilelist ha abilitato il dragEnabled in modo che i suoi elementi possano essere draggati (il datagrid non ha dropEnabled=true).

A questo punto se testiamo l’applicazione il drag degli elementi non porterà a nulla in quanto non esistono drop designati.

Iniziamo a scriptare questa struttura, sarà necessario importare le classi
- mx.core.DragSource
- mx.events.ListEvent
- mx.events.DragEvent
- mx.managers.DragManager
per far funzionare il tutto…e anche mx.controls.Alert ai fini dell’esempio portato nel tutorial.

Adesso è necessario definire alcuni metodi

private var _tempIndex:uint=0;//indice della cartella selezionata

//gestore dragEnter del datagrid
private function onDragEnter(e:DragEvent):void
{
	DragManager.acceptDragDrop(drop_dg);
}
//gestore dragOver del datagrid -> gestisce il "rollover" sugli elementi sotto il drag proxy
private function onDragOver(e:DragEvent):void
{
	drop_dg.selectedIndex = drop_dg.calculateDropIndex(e);
	DragManager.showFeedback(DragManager.MOVE);
}
//gestore del dragDrop del datagrid -> clona gli elementi droppati e li copia nel datagrid
private function onDragDrop(e:DragEvent):void
{
	var ds:DragSource = e.dragSource;
	var items:Array = ds.dataForFormat('items') as Array;
	var txt:String ="";
	for(var i:uint=0;i0){txt+=", ";}
		txt+=items[i].label;
	}
	txt+=" dropped into "+drop_dg.selectedItem.label;
	Alert.show(txt,"Dropped!");
	drop_dg.selectedIndex = _tempIndex;
}
//riposiziona il focus del datagrid al precedente indice
private function onDragComplete(e:DragEvent):void
{
	drop_dg.selectedIndex = _tempIndex;
}
//memorizza il focus da mantenere nel datagrid
private function onDgItemClick(e:ListEvent):void
{
	_tempIndex = drop_dg.selectedIndex;
}

dopo aver definito questi metodi per la gestione del drag\drop sarà necessario aggiungerne i gestori al datagrid direttamente dall’mxml:


dragEnter="onDragEnter(event)"
dragOver="onDragOver(event)"
dragComplete="onDragComplete(event)"
dragDrop="onDragDrop(event)"
itemClick="onDgItemClick(event)"


…e ora testando l’applicazione il risultato sarà il seguente

[flash http://www.flashfuck.it/wp-content/uploads/2007/11/dragdropintook.swf w=400 h=300]

Trascinando gli elementi sul datagrid non si avrà pi√π come riferimento il datagrid ma gli elementi del datagrid, grazie al metodo “calculateDropIndex” della classe ListBase (di cui DataGrid è un discendente).

Qui potete scaricare i files del tutorial: flashfuckdragndropinto.zip

(foto di uno spambot)

Esistono una marea di plugin anti spam, askimet su wordpress, tutta una sfilza di mod antispam per i forum di phpBB, e anche molti scriptini confezionati a mano che possono risultare pi√π o meno efficaci.
Ma i metodi pi√π diffusi identificano l’utente “spam-bot” per esclusione, chiedendo un’interazione in pi√π all’utente umano.

Percarità, lungi da me andare contro i metodi antispam di questo tipo (anche qui su FlashFuck c’è un antispam a pieno regime), ma la domanda a questo punto dev’essere “perchè devo chiedere ai miei utenti un qualcosa in pi√π quando potrei negare direttamente l’accesso agli spam bot?”.

Per poter fare questo prima bisogna capire come funziona uno spam bot, o quantomeno come si presenta al nostro sito.

Un utente (umano o robot) viene identificato dal nostro server con un ip, un host, un user agent, e altre informazioni.

Prendiamo in considerazione l’user agent.
Tracciando l’user agent di un utente umano noteremo che corrisponde alle informazioni del suo browser
es:Mozilla/5.0 (Macintosh; U; PPC Mac OS X; it-it) AppleWebKit/419.3 (KHTML, like Gecko) Safari/419.3 (questo è il mio Safari )
L’user agent di un robot quindi traccia il programma usato dal bot per raggiungere il sito….ossia il robot stesso
Per liberarsi di buona parte dei bot basterà quindi indirizzare tutti i robot indesiderati da un’altra parte (tipo su microsoft.com ) oppure vietar loro l’accesso.

Ecco una lista degli spambot pi√π noti da bannare dal sito dal vostro .htaccess:

RewriteEngine on
RewriteCond %{HTTP_USER_AGENT} ^Alexibot [OR]
RewriteCond %{HTTP_USER_AGENT} ^asterias [OR]
RewriteCond %{HTTP_USER_AGENT} ^BackDoorBot [OR]
RewriteCond %{HTTP_USER_AGENT} ^Black.Hole [OR]
RewriteCond %{HTTP_USER_AGENT} ^BlackWidow [OR]
RewriteCond %{HTTP_USER_AGENT} ^BlowFish [OR]
RewriteCond %{HTTP_USER_AGENT} ^BotALot [OR]
RewriteCond %{HTTP_USER_AGENT} ^BuiltBotTough [OR]
RewriteCond %{HTTP_USER_AGENT} ^Bullseye [OR]
RewriteCond %{HTTP_USER_AGENT} ^BunnySlippers [OR]
RewriteCond %{HTTP_USER_AGENT} ^Cegbfeieh [OR]
RewriteCond %{HTTP_USER_AGENT} ^CheeseBot [OR]
RewriteCond %{HTTP_USER_AGENT} ^CherryPicker [OR]
RewriteCond %{HTTP_USER_AGENT} ^ChinaClaw [OR]
RewriteCond %{HTTP_USER_AGENT} ^CopyRightCheck [OR]
RewriteCond %{HTTP_USER_AGENT} ^cosmos [OR]
RewriteCond %{HTTP_USER_AGENT} ^Crescent [OR]
RewriteCond %{HTTP_USER_AGENT} ^Custo [OR]
RewriteCond %{HTTP_USER_AGENT} ^DISCo [OR]
RewriteCond %{HTTP_USER_AGENT} ^DittoSpyder [OR]
RewriteCond %{HTTP_USER_AGENT} ^Download\ Demon [OR]
RewriteCond %{HTTP_USER_AGENT} ^eCatch [OR]
RewriteCond %{HTTP_USER_AGENT} ^EirGrabber [OR]
RewriteCond %{HTTP_USER_AGENT} ^EmailCollector [OR]
RewriteCond %{HTTP_USER_AGENT} ^EmailSiphon [OR]
RewriteCond %{HTTP_USER_AGENT} ^EmailWolf [OR]
RewriteCond %{HTTP_USER_AGENT} ^EroCrawler [OR]
RewriteCond %{HTTP_USER_AGENT} ^Express\ WebPictures [OR]
RewriteCond %{HTTP_USER_AGENT} ^ExtractorPro [OR]
RewriteCond %{HTTP_USER_AGENT} ^EyeNetIE [OR]
RewriteCond %{HTTP_USER_AGENT} ^FlashGet [OR]
RewriteCond %{HTTP_USER_AGENT} ^Foobot [OR]
RewriteCond %{HTTP_USER_AGENT} ^FrontPage [NC,OR]
RewriteCond %{HTTP_USER_AGENT} ^GetRight [OR]
RewriteCond %{HTTP_USER_AGENT} ^GetWeb! [OR]
RewriteCond %{HTTP_USER_AGENT} ^Go-Ahead-Got-It [OR]
RewriteCond %{HTTP_USER_AGENT} ^Go!Zilla [OR]
RewriteCond %{HTTP_USER_AGENT} ^GrabNet [OR]
RewriteCond %{HTTP_USER_AGENT} ^Grafula [OR]
RewriteCond %{HTTP_USER_AGENT} ^Harvest [OR]
RewriteCond %{HTTP_USER_AGENT} ^hloader [OR]
RewriteCond %{HTTP_USER_AGENT} ^HMView [OR]
RewriteCond %{HTTP_USER_AGENT} ^httplib [OR]
RewriteCond %{HTTP_USER_AGENT} ^HTTrack [NC,OR]
RewriteCond %{HTTP_USER_AGENT} ^humanlinks [OR]
RewriteCond %{HTTP_USER_AGENT} ^Image\ Stripper [OR]
RewriteCond %{HTTP_USER_AGENT} ^Image\ Sucker [OR]
RewriteCond %{HTTP_USER_AGENT} ^Indy\ Library [NC,OR]
RewriteCond %{HTTP_USER_AGENT} ^InfoNaviRobot [OR]
RewriteCond %{HTTP_USER_AGENT} ^InterGET [OR]
RewriteCond %{HTTP_USER_AGENT} ^Internet\ Ninja [OR]
RewriteCond %{HTTP_USER_AGENT} ^JennyBot [OR]
RewriteCond %{HTTP_USER_AGENT} ^JetCar [OR]
RewriteCond %{HTTP_USER_AGENT} ^JOC\ Web\ Spider [OR]
RewriteCond %{HTTP_USER_AGENT} ^Kenjin.Spider [OR]
RewriteCond %{HTTP_USER_AGENT} ^Keyword.Density [OR]
RewriteCond %{HTTP_USER_AGENT} ^larbin [OR]
RewriteCond %{HTTP_USER_AGENT} ^LeechFTP [OR]
RewriteCond %{HTTP_USER_AGENT} ^LexiBot [OR]
RewriteCond %{HTTP_USER_AGENT} ^libWeb/clsHTTP [OR]
RewriteCond %{HTTP_USER_AGENT} ^LinkextractorPro [OR]
RewriteCond %{HTTP_USER_AGENT} ^LinkScan/8.1a.Unix [OR]
RewriteCond %{HTTP_USER_AGENT} ^LinkWalker [OR]
RewriteCond %{HTTP_USER_AGENT} ^lwp-trivial [OR]
RewriteCond %{HTTP_USER_AGENT} ^Mass\ Downloader [OR]
RewriteCond %{HTTP_USER_AGENT} ^Mata.Hari [OR]
RewriteCond %{HTTP_USER_AGENT} ^MIDown\ tool [OR]
RewriteCond %{HTTP_USER_AGENT} ^MIIxpc [OR]
RewriteCond %{HTTP_USER_AGENT} ^Mister.PiX [OR]
RewriteCond %{HTTP_USER_AGENT} ^Mister\ PiX [OR]
RewriteCond %{HTTP_USER_AGENT} ^moget [OR]
RewriteCond %{HTTP_USER_AGENT} ^Mozilla/2 [OR]
RewriteCond %{HTTP_USER_AGENT} ^Mozilla/3.Mozilla/2.01 [OR]
RewriteCond %{HTTP_USER_AGENT} ^Mozilla.*NEWT [OR]
RewriteCond %{HTTP_USER_AGENT} ^Navroad [OR]
RewriteCond %{HTTP_USER_AGENT} ^NearSite [OR]
RewriteCond %{HTTP_USER_AGENT} ^NetAnts [OR]
RewriteCond %{HTTP_USER_AGENT} ^NetMechanic [OR]
RewriteCond %{HTTP_USER_AGENT} ^NetSpider [OR]
RewriteCond %{HTTP_USER_AGENT} ^Net\ Vampire [OR]
RewriteCond %{HTTP_USER_AGENT} ^NetZIP [OR]
RewriteCond %{HTTP_USER_AGENT} ^NICErsPRO [OR]
RewriteCond %{HTTP_USER_AGENT} ^NPBot [OR]
RewriteCond %{HTTP_USER_AGENT} ^Octopus [OR]
RewriteCond %{HTTP_USER_AGENT} ^Offline.Explorer [OR]
RewriteCond %{HTTP_USER_AGENT} ^Offline\ Explorer [OR]
RewriteCond %{HTTP_USER_AGENT} ^Offline\ Navigator [OR]
RewriteCond %{HTTP_USER_AGENT} ^Openfind [OR]
RewriteCond %{HTTP_USER_AGENT} ^PageGrabber [OR]
RewriteCond %{HTTP_USER_AGENT} ^Papa\ Foto [OR]
RewriteCond %{HTTP_USER_AGENT} ^pavuk [OR]
RewriteCond %{HTTP_USER_AGENT} ^pcBrowser [OR]
RewriteCond %{HTTP_USER_AGENT} ^ProPowerBot/2.14 [OR]
RewriteCond %{HTTP_USER_AGENT} ^ProWebWalker [OR]
RewriteCond %{HTTP_USER_AGENT} ^ProWebWalker [OR]
RewriteCond %{HTTP_USER_AGENT} ^QueryN.Metasearch [OR]
RewriteCond %{HTTP_USER_AGENT} ^ReGet [OR]
RewriteCond %{HTTP_USER_AGENT} ^RepoMonkey [OR]
RewriteCond %{HTTP_USER_AGENT} ^RMA [OR]
RewriteCond %{HTTP_USER_AGENT} ^SiteSnagger [OR]
RewriteCond %{HTTP_USER_AGENT} ^SlySearch [OR]
RewriteCond %{HTTP_USER_AGENT} ^SmartDownload [OR]
RewriteCond %{HTTP_USER_AGENT} ^SpankBot [OR]
RewriteCond %{HTTP_USER_AGENT} ^spanner [OR]
RewriteCond %{HTTP_USER_AGENT} ^SuperBot [OR]
RewriteCond %{HTTP_USER_AGENT} ^SuperHTTP [OR]
RewriteCond %{HTTP_USER_AGENT} ^Surfbot [OR]
RewriteCond %{HTTP_USER_AGENT} ^suzuran [OR]
RewriteCond %{HTTP_USER_AGENT} ^Szukacz/1.4 [OR]
RewriteCond %{HTTP_USER_AGENT} ^tAkeOut [OR]
RewriteCond %{HTTP_USER_AGENT} ^Teleport [OR]
RewriteCond %{HTTP_USER_AGENT} ^Teleport\ Pro [OR]
RewriteCond %{HTTP_USER_AGENT} ^Telesoft [OR]
RewriteCond %{HTTP_USER_AGENT} ^The.Intraformant [OR]
RewriteCond %{HTTP_USER_AGENT} ^TheNomad [OR]
RewriteCond %{HTTP_USER_AGENT} ^TightTwatBot [OR]
RewriteCond %{HTTP_USER_AGENT} ^Titan [OR]
RewriteCond %{HTTP_USER_AGENT} ^toCrawl/UrlDispatcher [OR]
RewriteCond %{HTTP_USER_AGENT} ^toCrawl/UrlDispatcher [OR]
RewriteCond %{HTTP_USER_AGENT} ^True_Robot [OR]
RewriteCond %{HTTP_USER_AGENT} ^turingos [OR]
RewriteCond %{HTTP_USER_AGENT} ^TurnitinBot/1.5 [OR]
RewriteCond %{HTTP_USER_AGENT} ^URLy.Warning [OR]
RewriteCond %{HTTP_USER_AGENT} ^VCI [OR]
RewriteCond %{HTTP_USER_AGENT} ^VoidEYE [OR]
RewriteCond %{HTTP_USER_AGENT} ^WebAuto [OR]
RewriteCond %{HTTP_USER_AGENT} ^WebBandit [OR]
RewriteCond %{HTTP_USER_AGENT} ^WebCopier [OR]
RewriteCond %{HTTP_USER_AGENT} ^WebEMailExtrac.* [OR]
RewriteCond %{HTTP_USER_AGENT} ^WebEnhancer [OR]
RewriteCond %{HTTP_USER_AGENT} ^WebFetch [OR]
RewriteCond %{HTTP_USER_AGENT} ^WebGo\ IS [OR]
RewriteCond %{HTTP_USER_AGENT} ^Web.Image.Collector [OR]
RewriteCond %{HTTP_USER_AGENT} ^Web\ Image\ Collector [OR]
RewriteCond %{HTTP_USER_AGENT} ^WebLeacher [OR]
RewriteCond %{HTTP_USER_AGENT} ^WebmasterWorldForumBot [OR]
RewriteCond %{HTTP_USER_AGENT} ^WebReaper [OR]
RewriteCond %{HTTP_USER_AGENT} ^WebSauger [OR]
RewriteCond %{HTTP_USER_AGENT} ^Website\ eXtractor [OR]
RewriteCond %{HTTP_USER_AGENT} ^Website.Quester [OR]
RewriteCond %{HTTP_USER_AGENT} ^Website\ Quester [OR]
RewriteCond %{HTTP_USER_AGENT} ^Webster.Pro [OR]
RewriteCond %{HTTP_USER_AGENT} ^WebStripper [OR]
RewriteCond %{HTTP_USER_AGENT} ^Web\ Sucker [OR]
RewriteCond %{HTTP_USER_AGENT} ^WebWhacker [OR]
RewriteCond %{HTTP_USER_AGENT} ^WebZip [OR]
RewriteCond %{HTTP_USER_AGENT} ^Wget [OR]
RewriteCond %{HTTP_USER_AGENT} ^Widow [OR]
RewriteCond %{HTTP_USER_AGENT} ^[Ww]eb[Bb]andit [OR]
RewriteCond %{HTTP_USER_AGENT} ^WWW-Collector-E [OR]
RewriteCond %{HTTP_USER_AGENT} ^WWWOFFLE [OR]
RewriteCond %{HTTP_USER_AGENT} ^Xaldon\ WebSpider [OR]
RewriteCond %{HTTP_USER_AGENT} ^Xenu's [OR]
RewriteCond %{HTTP_USER_AGENT} ^Zeus
RewriteRule ^(.*)$ http://www.sitodidestinazione.com/

Il sito di destinazione puo’ essere cambiato con quello che volete, anche con un divieto d’accesso sostituendo l’ultima riga di codice con:
RewriteRule ^.* - [F]
ma l’user agent non è la sola discriminante da tenere in considerazione

Prendiamo in considerazione l’ip.
L’ip di un utente umano è verosimilmente l’ip della macchina con cui sta navigando, oppure un ip mascherato da qualche proxy. Uno spambot invece si presenta verosimilmente con l’ip di qualche proxy per mascherarsi al suo passaggio…
Quindi nelle regole di accesso al sito si dovrà aggiungere tutti i proxy potenzialmente dannosi.
Dal sito proxy.org si può recuperare una lista nera dei proxy tor potenzialmente dannosi e aggiungerla al proprio .htaccess.
Ecco il link al file contenente delle aggiunte per bannare anche gli “utenti” provenienti dai proxy cattivi.

Ecco, adesso non dico che si possa dormire tra due guanciali, ma almeno non si sarà un bersaglio ghiotto per gli spambot…

ma vediamo di cosa si tratta…

“AS3 Data Structures For Game Developers” is a package containing common data structures useful for flash game programming and application development, mai descrizione fu pi√π sintetica e completa.

Il package contiene infatti diverse strutture di dati utili alla rappresentazione delle diverse situazioni riscontrabili sia nella programmazione di videogames che in quella delle applicazioni (anche nelle pi√π semplici).

Le strutture di dati di questo package suppliscono alla “semplicità” dei tipi di AS3, vengono implementate infatti strutture largamente diffuse e utilizzate dai pi√π come

• array multidimensionali (2 e 3 dimensioni)
• alberi e alberi binari
• liste concatenate
• code di priorità
• grafici (graph)

La documentazione del package è ottima (http://www.polygonal.de/ds/api/) e non ci sono lacune di sorta o concetti lasciati all’interpretazione.

L’utilizzo di queste strutture di dati, o meglio, l’approccio a questo “nuovo” (che poi nuovo non è, questo è solo un porting in AS3 delle strutture pi√π utilizzate nella logica di programmazione) modo di archiviare i dati può intimorire un newbie che sta solo cercando di fare la sua image gallery, ma una volta sperimentato questo package sarà la base da cui partire, quindi

import flash.display.Sprite;
import de.polygonal.ds.*;

e buon coding!

Se la domanda che vi assilla è:
“Come si fa ad adattare un swf alle dimensioni della finestra del browser in modo che il risultato sia compatibile con i maggiori browser?” continuate pure a leggere

Partiamo dalle basi:

Dentro Flash:

Il flash player fornisce ad Actionscript una serie di API destinate all’interazione con lo stage del nostro swf fin dai tempi di flash mx.
Utilizzare questi appigli per determinare le dimensioni del nostro swf in esecuzione è piuttosto semplice e richiede davvero poche righe di codice:

Actionscript 2:

Stage.scaleMode = "noScale";
Stage.align = "TL";
var myListener:Object = new Object();
myListener.onResize = onScreenResize;
Stage.addListener(myListener);

function onScreenResize():Void
{
	trace(Stage.width);
	trace(Stage.height);
}

Actionscript 3:

import flash.display.StageAlign;
import flash.display.StageScaleMode;
import flash.events.*;

stage.scaleMode = StageScaleMode.NO_SCALE;
stage.align = StageAlign.TOP_LEFT;
//assegno la funzione al gestore evento
stage.addEventListener(Event.RESIZE,onScreenResize);
//funzione per gestire il resize
//(e=null di default per evitare errori a runtime)
function onScreenResize(e:Event=null):void
{
	trace(stage.stageWidth);
	trace(stage.stageHeight);
}

La logica come potete vedere è la medesima:

• si blocca il ridimensionamento automatico dello stage (ossia lo “zoom” indesiderato)
• si allinea lo stage in una delle 9 posizioni possibili (da top-left a bottom-right)
• si va a gestire l’evento onResize dell’oggetto Stage in una funzione che esegue del codice a nostro uso e consumo

Cambia un pochino la sintassi, ma è solo questione di abitudine
Nel codice HTML e nel foglio di stile CSS:

ora possiamo passare alla parte xhtml e css, ossia quella parte che effettivamente va a gestire le dimensioni del player all’interno del browser.

Gli elementi della ricetta sono i seguenti:

• un div
• le direttive di stile per gli elementi del DOM “html”, “body” e “#nomediv”
• SWFObject a piacere per scrivere il nostro swf in #nomediv

Il nostro CSS apparirà simile a questo:

html {
	height: 100%;
	overflow: hidden;
}
#flashdiv {
	height: 100%;
}
body {
	height: 100%;
	margin: 0;
	padding: 0;
	background-color: #FFFFFF;
}

Conclusione e Sorgenti

Questo è solo uno dei vari modi in cui si può ottenere un swf grande quanto la finestra del browser e compatibile con la maggior parte dei browser in circolazione.

Ad ogni modo, nel file zip ci sono i vari casi elencati in questo mini “tutorial”,

stay tuned

La risposta è:
esiste un hack a riguardo fin dai tempi di flash mx.

Funziona così:
si maschera un movieclip direttamente da timeline, gli si assegna un nome istanza (ad esempio “myClip”).
Una volta mascherato si può procedere con la parte di script.

myClip.attachMovie("movieclipinlibreria","nome",myClip.getDepth()-1);

così facendo il nuovo clip inserito nello stage sarà mascherato esattamente come myClip.

Quanto vale per attachMovie vale anche per createEmptyMovieClip, basterà mantenere il livello “myClip.getDepth()-1″ per rientrare nel caso.

Ma, se volessi mascherare direttamente il mio clip via actionscript senza doverlo mascherare da timeline?
Qui casca l’asino.
Con questo “hack” non si elude il metodo setmask della classe MovieClip, è solo un modo per raggirarlo facendo leva sui livelli.
Un modo per ovviare al problema però esiste.
Nessuno ha detto che myClip debba essere visibile o non vuoto.
Creando in libreria un movieclip “mc_mascherato” nel quale posiziono una maschera e un “myClip” vuoto si potrebbe replicare la situazione all’infinito utilizzando come timeline di riferimento proprio quella di mc_mascherato anzichè quella principale.
Le applicazioni di questo “hack” per il multi masking sono davvero tante, dalla image gallery all’intro animata, ad una semplice transizione.

Quasi dimenticavo, qui potete scaricarvi un esempio base.qui potete scaricarvi un esempio base

Gestire l’onReleaseOutside in actionscript 3 è però pi√π facile di quanto si possa credere.
Scaricatevi questo file >> onReleaseOutside actionscript 3

Dentro ci troverete due classi:
la classe interessante è “Button.as”.

La classe Button estende la classe nativa di actionscript 3 “SimpleButton” e aggiunge semplicemente il gestore dell’evento release outside.

Con as3 è possibile rilevare l’ onRelease e l’ onRollOut di un SimpleButton tramite i gestori di evento della classe MouseEvent.
Ma come è possibile combinare questi due eventi per gestire l’ onReleaseOutside?
La logica è la seguente:

1. all’ onRollOut del mouse sul pulsante controlla se il mouse è ancora premuto
2. se il mouse è ancora premuto aggiungi un event listener sul release del mouse rispetto allo stage

Niente di complesso… diamo un’occhiata al codice:

//gestore del press

internal function onPress(e:MouseEvent):void

{

 trace("press");

}//gestore del release

internal function onRelease(e:MouseEvent):void

{

 trace("release");

}

//gestore del FAMIGERATO release outside

internal function onReleaseOutside(e:MouseEvent):void

{

 trace("release outside");

}

//gestore del rollout

internal function onRollOut(e:MouseEvent):void

{

 trace("rollout");

 if(e.buttonDown){

//QUI AGGIUNGO L'EVENTO PER GESTIRE IL RELEASE OUTSIDE

 	e.target.stage.addEventListener(MouseEvent.MOUSE_UP, onReleaseOutside);

 }

}

//gestore del rollover

internal function onRollOver(e:MouseEvent):void

{

 trace("rollover");

//al rollover del mouse sul pulsante elimino il releaseoutside

 e.target.stage.removeEventListener(MouseEvent.MOUSE_UP, onReleaseOutside);

}

Nel file zip allegato trovate il resto della classe Button e una classe flashfuckit (bel nome eh? ) per visualizzare l’esempio.