bye for now

Have a huge coffee cup and take a read
Here’s the link

this is the specific case:

function checkType(toCheck:Class,typeClass:Class=null,typeInterface:Class=null):Boolean
{
// if an instance of toCheck is a typeClass or a typeInterface
// return true
// else
// return false
}

The task is quite simple, the first solution would be get an instance of toCheck and use the is operator to actually check the type…but this would mean both a waste of resources and an “unwanted behaviour generator” (just think about a parser class instantiated without a real need or something like that).

Nope, that solution sucks.

Let’s try something better, let’s make the player inform us which is the toCheck class structure, let’s use describeType.

describeType is a wonderful function you can find in flash.utils package, it examines an untyped object and returns an xml document containing the description of that type (more details at adobe livedocs)…something like this:

NOTE: click on “view code” to see the real xml document, my wp is escaping tags chars <> …:\

<type name="flash.events::EventDispatcher" base="Class" isDynamic="true" isFinal="true" isStatic="true">
  <extendsClass type="Class"/>
  <extendsClass type="Object"/>
  <accessor name="prototype" access="readonly" type="*" declaredBy="Class"/>
  <factory type="flash.events::EventDispatcher">
    <metadata name="Event">
      <arg key="name" value="deactivate"/>
      <arg key="type" value="flash.events.Event"/>
    </metadata>
    <metadata name="Event">
      <arg key="name" value="activate"/>
      <arg key="type" value="flash.events.Event"/>
    </metadata>
    <extendsClass type="Object"/>
    <implementsInterface type="flash.events::IEventDispatcher"/>
    <constructor>
      <parameter index="1" type="*" optional="true"/>
    </constructor>
    <method name="willTrigger" declaredBy="flash.events::EventDispatcher" returnType="Boolean">
      <parameter index="1" type="String" optional="false"/>
    </method>
    <method name="hasEventListener" declaredBy="flash.events::EventDispatcher" returnType="Boolean">
      <parameter index="1" type="String" optional="false"/>
    </method>
    <method name="removeEventListener" declaredBy="flash.events::EventDispatcher" returnType="void">
      <parameter index="1" type="String" optional="false"/>
      <parameter index="2" type="Function" optional="false"/>
      <parameter index="3" type="Boolean" optional="true"/>
    </method>
    <method name="dispatchEvent" declaredBy="flash.events::EventDispatcher" returnType="Boolean">
      <parameter index="1" type="flash.events::Event" optional="false"/>
    </method>
    <method name="addEventListener" declaredBy="flash.events::EventDispatcher" returnType="void">
      <parameter index="1" type="String" optional="false"/>
      <parameter index="2" type="Function" optional="false"/>
      <parameter index="3" type="Boolean" optional="true"/>
      <parameter index="4" type="int" optional="true"/>
      <parameter index="5" type="Boolean" optional="true"/>
    </method>
    <method name="toString" declaredBy="flash.events::EventDispatcher" returnType="String"/>
  </factory>
</type>

As you can see in this EventDispatcher type description there are two nodes witch are fitting the task’s purposes:

<extendsClass> and <implementsInterface>

Those nodes are repeated for each class or interface in the given class (toCheck) chain of inheritance and they contain the qualified class name string of the extended\implemented class\interface.

In this case EventDispatcher extendsClass type=’Object’ and implementsInterface type=’flash.events::IEventDispatcher’ …quite clear right?:) Now, back to the implementation:

function checkType(toCheck:Class,typeClass:Class=null,typeInterface:Class=null):Boolean
{
	//gets the toCheck class type xml description
	var _typeXML:XML=describeType(toCheck);
	//gets the typeClass and typeInterface qualified class names
	var _result:Boolean=false;
	if (typeClass) {
		// if toCheck is a typeClass
		for each (var _extClass:XML in _typeXML.factory.elements('extendsClass')) {
			if (_extClass.@type==getQualifiedClassName(typeClass)) {
				_result=true;
				break;
			}
		}
	}
	// do the same for typeInterface but checking 'implementsInterface' node
	if (typeInterface) {
		for each (var _impInterface:XML in _typeXML.factory.elements('extendsClass')) {
			if (_impInterface.@type==getQualifiedClassName(typeInterface)) {
				_result=true;
				break;
			}
		}
	}
 
	return _result;
}

…and the task got done

stay tuned

So, let’s open a trace logger on our terminal…

To do that the right command is “tail” which actually “[...]Print  the  last 10 lines of each FILE to standard output[...]” and the file to open is located in /Users/[your username]/Library/Preferences/Macromedia/Flash\ Player/Logs/flashlog.txt

Then, let’s do something good and useful with that:

open your TextEdit, cmd+shift+T to switch to plain text, write down this one line command:

tail -f /Users/[your username]/Library/Preferences/Macromedia/Flash\ Player/Logs/flashlog.txt

save the file as “flashtracer.sh” and use sh as file extension instead of txt.

then right click on the file, reach the “open with” menu and choose “terminal” application located inside utility folder. Note: it would be great if you set terminal as default application to open that file

ok, now everything’s ready; double click on flashtracer.sh and start tracing

Note: remember you’re in a shell now, so you can clear up the lines with cmd+K…

I hope it can be useful,

byez

I don’t know if someone would be interested in this kind of experiments, there are many good projects that make 3D approach easier than build your own engine. However even if Papervision or Away3D let us make 3D content (..oh, i forgot to add flash 10 to this list ) I think it’s always better to understand what’s going on behind the scenes to better comprehend what’s the magic made of

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:

questo il fla dell’esempio (CS3) Download Source

tasty

http://developer.yahoo.com/flash/articles/flex-skinning.html

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:

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;i<items.length;i++){
		if(i>0){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

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

Il problema che andrò ad affrontare è il seguente:
come faccio a comunicare ad una classe il risultato di una funzione, o pi√π generalmente dei “dati” elaborati in maniera asincrona da un’altra classe istanziata nella mia classe di partenza?

Se i dati fossero elaborati e restituiti in diretta non ci si porrebbe il problema, esempio ne sono le classi di largo consumo come Math e Date (es: var mioint:int = Math.round(9.99999)).

Ma se volessi delegare (termine usato non a caso, visto i trascorsi di as2 ) a delle classi customizzate la mole di lavoro tipo delle routines di caricamento o qualcosa di simile?

Poniamo il caso di voler caricare una configurazione per la nostra applicazione\sito\game\… che risiede su un file cfg.xml.
Potremmo fare il tutto all’interno della document class cos√¨,

1. creiamo una private var _cfgxml:XML
2. nel costruttore andiamo a caricarci i dati con var myLoader:URLLoader = new URLLoader(new URLRequest(‘cfg.xml’));
3. appioppiamo al loader un gestore di evento Event.COMPLETE a cui associamo il parsing dei dati myLoader.addEventListener(Event.COMPLETE,cfgParse);
4. creiamo private function cfgParse(e:Evento) in cui istanziamo _cfgxml = new XML(e.target.data);

Ok, √® un’ipotesi plausibile, ma se questo nostro file richiedesse attenzioni particolari? o se semplicemente volessimo delegare ad altre classi le funzioni di parsing, di comunicazione con componenti, ecc ecc, solo per la soddisfazione di essere pi√π “puliti” nel codice…?

In actionscript 2 avremmo utilizzato Delegate passando come argomento la timeline (o l’istanza di classe) di riferimento. Ma in actionscript 3 “Delegate √® stat’ segheit”

Si rende quindi necessario passare la timeline\istanzadiclasse di riferimento come parametro per l’istanziazione della classe che elaborer√† i dati.

Esempio:

document class

private var _cfg:CFGManager;
 
public function Main(){
//costruttore
_cfg = new CFGManager(this);
_cfg.loadCFG();
 
}public function continuaMainClass(){}

classe richiamata dalla document class

private var _main:Main; //riferimento alla classe chiamante
public function CFGManager(m:Main){//costruttore
_main=m;//qui vado a memorizzare i riferimenti al main
}
 
public function loadCFG(){
//qui carico il mio xml di configurazione
//appioppo l'event listener per il caricamento
//e poi passo il tutto a parseCFG
}
private function parseCFG(e:Event){
//qui parso l'xml da e.target.data
//e poi faccio continuare l'esecuzione del main
_main.continuaMainClass();
}

Perfortuna non è nulla di così complesso

Per ottimizzare il tutto per√≤ sar√† opportuno non ricevere in ingresso un parametro fortemente tipizzato, ad esempio la classe CFGManager accetta in input solo parametri di tipo “Main”…se si vuole “astrarre” il codice, in modo da renderlo riutilizzabile sar√† opportuno che accetti potenzialmente qualsiasi tipo di dato, da DisplayObject all’estremo “*”…ma poi sono gusti

avevo detto che sarei stato breve, quindi alla prossima

Ma perch√® darla vinta agli spammers cambiando l’engine del forum (passando a vBulletin o a chiss√† quale altro) o perseverando nell’eliminare gli utenti fasulli uno ad uno?

Ecco qualche accorgimento per diventare uno

e godersi il proprio forum phpBB gratuito…

Premessa

Applicando questo metodo non si eliminano tutti gli spambot, ma si riducono parecchio.
Per rendere l’idea, in un forum che fa circa 3000 visite al mese privo di qualsiasi mod antispam al quale si registravano mediamente 2/3 bot al giorno gli utenti fasulli e registrazioni di spambot sono diminuite a meno di 5 al mese.

Esistono una serie di mod e accorgimenti da adottare per combattere la spam, questo √® uno di quelli (solo che non me la sento di chiamarlo “mod” )

Inoltre, “si dice” che la versione 3 risolva questi problemi, ma “si dice” anche il contrario, quindi, sotto a moddare!

La Versione di phpBB

Innanzitutto controllate la versione, quello che sto scrivendo l’ho testato su un phpBB 2.0.x.

Cosa va modificato

Vanno sistemati 3 files

• admin/admin_users.php
• includes/usercp_avatar.php
• includes/usercp_register.php

La modifica da fare in ciascun file è molto semplice.
Gli spambot forzano la registrazione passando alcuni argomenti alle pagine relative alla registrazione al forum, quindi sarà su quei parametri che bisognerà agire.

Fate un bel find della variabile “agreed” all’interno dei tre files e sostituitela con quella che pi√π vi piace (tipo “ciccio” o “cuccureddu”, o anche “assoreta” non √® male , visto che so gi√† che la fantasia si sprecher√† ricordatevi che sono variabili passate in GET, quindi evitate nomi variabile troppo lunghi

Rispettivamente le occorrenze della parola agreed nei files originali di phpBB sono 2 per admin_users.php 1 per usercp_avatar.php e 5 per usercp_register.php.

OK,
Adesso che √® stata cambiata la via d’accesso alla registrazione provate i percorsi di registrazione (sia quello per maggiori che per minori di 13 anni) e verificate che vada tutto liscio.
Noterete che nell’url della pagina di registrazione sar√† qualcosa del tipo http://www.nomesito.it/forum/profile.php?mode=register&NOMEVARIABILEMODIFICATA=true

Un altro accorgimento da tenere in considerazione √® intervenire direttamente sull’accesso degli spambot al sito stesso andando a modificare .htaccess …ma di quello vi ho gi√† parlato