Se você procurar na internet sobre SoundTransform, vai achar alguns exemplos de como fazer. Apenas modifiquei para ficar mais fácil a integração com qualquer aplicação.

Segue o código do método que implementei para a classe SoundTransformExample:

private function distance(pm:Array):Number
{
var px:Number = stage.stageWidth / 2;
var py:Number = stage.stageHeight / 2;
return Math.abs(Math.sqrt(Math.pow(pm[0] - px,2) + Math.pow(pm[1] - py,2)));
}

Adicione essa função no final da classe e passe a posição x e y do mouse no método mouseMoveHandler:

Isso vai fazer com que o volume seja ajustado de acordo com a distância do mouse em relação ao centro do palco. É possível colocar outros pontos de referência, mas esse exemplo foi só pra explicar como modificar o som.

Isso é tudo.

Faça o download dos arquivos utilizados.

Note que o flash vai tentar carregar o arquivo “MySound.mp3″ da pasta principal, mas ele não existe. Para funcionar, coloque um arquivo mp3 com este mesmo nome.

import flash.display.DisplayObject;
import flash.geom.Point;
public class ControlColision
{
public function ControlColision()
{
}
public function checkColision(_target:AbstractObject,_checkObject:DisplayObject):void
{
var sizeW:Number = _target.width;
var sizeH:Number = _target.height;
while(_checkObject.hitTestPoint(_target.x, _target.y, true))
{
_target.Yspeed = -Math.abs((_target.Yspeed / Constants.GRAVITY_DIVIDER));
_target.y -= Constants.gravity;
_target.setState(AbstractObject.STATE_STOP);
}
while(_checkObject.hitTestPoint(_target.x + (sizeW / 2), _target.y - (sizeH / 2), true))
{
_target.Xspeed = -Math.abs((_target.Xspeed / Constants.GRAVITY_DIVIDER));
_target.x -= 0.2;
}
while(_checkObject.hitTestPoint(_target.x - (sizeW / 2), _target.y - (sizeH / 2), true))
{
_target.Xspeed = Math.abs((_target.Xspeed / Constants.GRAVITY_DIVIDER));
_target.x += 0.2;
}
while(_checkObject.hitTestPoint(_target.x, _target.y - sizeH, true))
{
_target.Yspeed = Math.abs((_target.Yspeed / Constants.GRAVITY_DIVIDER));
_target.y += Constants.gravity;
}
while(_checkObject.hitTestPoint(_target.x + (sizeW / 4), _target.y - 1, true))
{
_target.Xspeed = -Math.abs((_target.Xspeed / Constants.GRAVITY_DIVIDER));
_target.x -= 0.2;
}
while(_checkObject.hitTestPoint(_target.x - (sizeW / 4), _target.y - 1, true))
{
_target.Xspeed = Math.abs((_target.Xspeed / Constants.GRAVITY_DIVIDER));
_target.x += 0.2;
}
while(_checkObject.hitTestPoint(_target.x + 5, _target.y - (sizeH - 1), true))
{
_target.Xspeed = -Math.abs((_target.Xspeed / Constants.GRAVITY_DIVIDER));
_target.x -= 0.2;
}
while(_checkObject.hitTestPoint(_target.x - 5, _target.y - (sizeH - 1), true))
{
_target.Xspeed = Math.abs((_target.Xspeed / Constants.GRAVITY_DIVIDER));
_target.x += 0.2;
}
}
}

Essa classe faz a verificação do objeto nos seguintes pontos:

Para usar essa classe e verificar a colisão com vários outros objetos no palco, além de usar os parâmetros
do objeto como “Xspeed” e “Yspeed”, é preciso ter mais três outras classes que auxiliam e completam o sistema de verificação. As classes são: “Constants”, “AbstractObject” e “ColisionList”.

• A Constants tem todos os valores principais que são usados em todas as outras.
• AbstractObject é responsável por armazenar os valores de velocidade vertical e horizontal e servir como uma interface, onde todos os movieclips ou objetos podem herdar suas funções.
• ColisionList é onde serão armazenados todos os objetos que vão colidir entre si.

Abaixo segue os códigos na respectiva ordem:

public class Constants
{
public static const STAGE_WIDTH:uint = 640;
public static const STAGE_HEIGHT:uint = 420;
public static const SPEED_LIMIT:Number = 10;
public static const SPEED_MINIMUM:Number = 0.294;
public static const ACCELERATION_LIMIT:Number = 3;
public static const GRAVITY_DIVIDER:uint = 8;
private static var configSpeed:Number = 0.7;
private static var configGravity:Number = 0.2;
private static var configJump:Number = configGravity * 20;
private static var configBound:Number = 0.98;
private static var configAcceleration:Number = 0.2;
public static function get gravity():Number
{
return configGravity;
}
public static function set gravity(_value:Number):void
{
configGravity = _value;
}
public static function get bound():Number
{
return configBound;
}
public static function set bound(_value:Number):void
{
configBound = _value;
}
public static function get speed():Number
{
return configSpeed;
}
public static function set speed(_value:Number):void
{
configSpeed = _value;
}
public static function get acceleration():Number
{
return configAcceleration;
}
public static function set acceleration(_value:Number):void
{
configAcceleration = _value;
}
public static function get jump():Number
{
return configJump;
}
public static function set jump(_value:Number):void
{
configJump = _value;
}
}


import flash.display.MovieClip;
import flash.events.Event;
public class AbstractObject extends MovieClip
{
public static const STATE_STOP:uint = 1;
public static const STATE_WALK:uint = 2;
public static const STATE_RUN:uint = 3;
public static const STATE_LOWERED:uint = 4;
public static const STATE_ROLL:uint = 5;
public static const STATE_JUMP:uint = 6;
public static const STATE_FLY:uint = 7;
private var velocity:Array;
private var acceleration:Number;
private var accCount:uint;
private var accCountMax:uint;
private var gravity:Number;
private var state:uint;
public function AbstractObject()
{
this.setObjectConfig();
}
private function setObjectConfig():void
{
try
{
this.state = STATE_STOP;
this.acceleration = 0;
this.accCount = 0;
this.accCountMax = Constants.ACCELERATION_LIMIT;
this.addEventListener(Event.ENTER_FRAME, this.refreshAcceleration);
this.setGravity(Constants.gravity);
this.velocity = [0,0];
}
catch(e:Error)
{
trace("(AbstractObject) Erro ao tentar setar configuração: " + e);
}
}
private function refreshAcceleration(evt:Event):void
{
this.accCount++;
if(this.accCount >= Constants.ACCELERATION_LIMIT && this.acceleration > 0)
{
this.acceleration -= Constants.acceleration;
}
}
public function set Xspeed(_value:Number):void
{
this.velocity[0] = _value;
}
public function get Xspeed():Number
{
return this.velocity[0];
}
public function set Yspeed(_value:Number):void
{
this.velocity[1] = _value;
}
public function get Yspeed():Number
{
return this.velocity[1];
}
public function setAcceleration(_value:Number):void
{
this.acceleration = _value;
this.accCount = 0;
}
public function addAcceleration(_value:Number):void
{
this.acceleration += _value;
this.accCount = 0;
if(this.acceleration > Constants.ACCELERATION_LIMIT)
{
this.acceleration = Constants.ACCELERATION_LIMIT;
}
}
public function getAcceleration():Number
{
return this.acceleration;
}
public function setGravity(_value:Number):void
{
this.gravity = _value;
}
public function getGravity():Number
{
return this.gravity;
}
public function setState(_value:uint):void
{
this.state = _value;
}
public function getState():uint
{
return this.state;
}
}

import colision.controller.ControlColision;
import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.events.Event;
public class ColisionEngine extends Sprite
{
private var running:Boolean;
private var target:AbstractObject;
private var checkObjectList:Array;
private var control:ControlColision;
public function ColisionEngine()
{
this.running = false;
this.control = new ControlColision();
}
public function initialize(_target:AbstractObject):void
{
if(_target != null)
{
this.target = _target;
this.checkObjectList = new Array();
this.startCheckColision();
}
}
public function startCheckColision():void
{
if(this.target != null && (!this.running))
{
this.running = true;
this.addEventListener(Event.ENTER_FRAME, this.checkColision);
}
}
public function stopCheckColision():void
{
if(this.running)
{
this.running = false;
this.removeEventListener(Event.ENTER_FRAME, this.checkColision);
}
}
private function checkColision(evt:Event):void
{
for(var a:uint = 0; a < this.checkObjectList.length; a++)
{
this.control.checkColision(this.target, this.checkObjectList[a]);
}
}
public function addColisionObject(_obj:DisplayObject):void
{
if(this.checkObject(_obj) <= 1)
{
this.checkObjectList.push(_obj);
}
}
public function checkObject(_obj:DisplayObject):int
{
var result:int = -1;
for(var a:uint = 0; a 0)
{
var tempList:Array = new Array();
for(var a:uint = 0; a < this.checkObjectList.length; a++)
{
if(a != _index)
{
tempList.push(this.checkObjectList[a]);
}
}
this.checkObjectList = tempList;
}
}
}

Existe mais uma classe que criei para testar esses métodos de colisão que coloquei o nome de “Main”.

import colision.ColisionEngine;
import flash.display.DisplayObject;
import flash.display.MovieClip;
import flash.display.Sprite;
import flash.events.KeyboardEvent;
import gravity.GravityEngine;
import moviment.controller.ControlMoviment;
import moviment.elements.AbstractObject;
public class Main extends Sprite
{
public function Main()
{
var ball:MovieClip = new YellowBall();
var retangulo:MovieClip = new BlueSquare();
ball.x = 300;
retangulo.x = 300;
retangulo.y = 300;
this.addChild(DisplayObject(retangulo));
var gravityBall:GravityEngine = new GravityEngine();
var movimentBall:ControlMoviment = new ControlMoviment();
var colisionBall:ColisionEngine = new ColisionEngine();
colisionBall.initialize(AbstractObject(ball));
colisionBall.addColisionObject(retangulo);
movimentBall.initialize(AbstractObject(ball));
stage.addEventListener(KeyboardEvent.KEY_DOWN, movimentBall.keyDown);
stage.addEventListener(KeyboardEvent.KEY_UP, movimentBall.keyUp);
gravityBall.addObject(AbstractObject(ball));
gravityBall.setGravity(1,0.5);
this.addChild(ball);
}
}

Dentro do fla, existe dois movieclips que são a bola e o retângulo assim como está descrito no início do construtor da classe Main.

Exemplo:

Como visto na imagem acima, existem dois objetos criados e em cada um deles a classe básica é AbstractObject, pois todos os objetos entram na lista de colisão e cada um precisa ter os mesmos atributos.

Se você está se perguntando sobre os estados da classe AbstractObject. Eles servem para mostrar algum comportamento em relação ao movimento.
Faça um teste e coloque sete frames dentro do objeto “bola” e em cada frame coloque uma cor diferente. Você vai observar que a cada estado o objeto pode ter comportamentos diferentes e isso pode ser aproveitado para um jogo tipo plataforma

Coloque a linkage do movieclip de “Objeto” e o nome da classe principal do fla de “Movimento”.

Após salvar o arquivo, crie mais duas classes “Objeto” e “Controle”:

package
{
import flash.display.MovieClip;
public class Objeto extends MovieClip
{
public var vx:Number;
public var vy:Number;
public var ax:Number;
public var ay:Number;
public function Objeto()
{
this.ax = 0;
this.ay = 0;
this.vx = 0;
this.vy = 0;
}
}
}

A classe objeto serve de interface entre o controlador de teclado (a classe Controle) e o objeto do palco “bolaMc”.

package
{
import flash.display.Sprite;
import flash.events.Event;
import flash.events.KeyboardEvent;
import flash.ui.Keyboard;
public class Controle extends Sprite
{
private var target:Objeto;
public function Controle(_target:Objeto)
{
this.target = _target;
}
public function initialize():void
{
this.addEventListener(Event.ENTER_FRAME, this.onEnterFrame);
}
private function onEnterFrame(evt:Event):void
{
this.target.vx += this.target.ax;
this.target.vy += this.target.ay;
this.target.x += this.target.vx;
this.target.y += this.target.vy;
}
public function onKeydown(e:KeyboardEvent):void{
if(e.keyCode == Keyboard.LEFT){
this.target.ax = - 0.1;
}else if(e.keyCode == Keyboard.RIGHT)
{
this.target.ax = 0.1;
}else if(e.keyCode == Keyboard.UP){
this.target.ay = -0.1
}else if(e.keyCode == Keyboard.DOWN){
this.target.ay = 0.1;
}
}
public function onKeyup(e:KeyboardEvent):void{
this.target.ax = 0;
this.target.ay = 0;
}
}
}

Agora vamos implementar a classe “Movimento”:

package
{
import flash.display.DisplayObject;
import flash.display.MovieClip;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.KeyboardEvent;
public class Movimento extends Sprite
{
private var teclado:Controle;
private var objBola:Objeto;
public function Movimento()
{
init();
}
private function init():void
{
this.objBola = new Objeto();
this.teclado = new Controle(this.objBola);
stage.addEventListener(KeyboardEvent.KEY_DOWN,this.teclado.onKeydown);
stage.addEventListener(KeyboardEvent.KEY_UP,this.teclado.onKeyup);
this.addChild(this.objBola);
this.objBola.x = stage.stageWidth / 2;
this.objBola.y = stage.stageHeight / 2;
this.teclado.initialize();
}
}
}

Pronto! Como foram feitas as classes e a organização foi só para o teste e exemplo. Uma boa organização pode abrir espaço para colocar gravidade e efeitos físicos.

Faça o download dos arquivos utilizados.

O nome da classe pode ser qualquer um, mas essa aqui se chama “LoadTest”.
Segue o código implementado da classe:
package
{
import flash.display.Sprite;
import flash.display.LoaderInfo;
public class LoadTest
{
private static var teste:String;
public function LoadTest()
{
init();
}
}
private function init():void
{
getParams();
trace(teste);
}
private function getParams():void{
var keyStr:String;
var valueStr:String;
var paramObj:Object = LoaderInfo(this.root.loaderInfo).parameters;
for(keyStr in paramObj){
valueStr = String(paramObj[keyStr]);
if(valueStr != null){
this[keyStr] = valueStr;
}
}
}
}


No html na parte de parâmetros da tag object do flash, adicione o parâmetro

Exemplo:

<object classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000"
        codebase="http://fpdownload.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=9,0,0,0"
        width="550"
        height="400"
        align="middle"
        id="teste">
    <param name="allowScriptAccess" value="sameDomain" />
    <param name="movie" value="teste.swf" />
    <param name="quality" value="high" />
    <param name="bgcolor" value="#ffffff" />
    <param name="FlashVars" value="teste=funcionou!" />
    <embed src="teste.swf"
           width="550"
           height="400"
           autostart="false"
           quality="high"
           bgcolor="#ffffff"
           FlashVars="teste=funcionou!"
           name="teste"
           align="middle"
           allowScriptAccess="sameDomain"
           type="application/x-shockwave-flash"
           pluginspage="http://www.macromedia.com/go/getflashplayer" />
</object>

Agora é só compilar que vai aparecer o conteúdo do parâmetro no output
No caso de querer mais parâmetros é só separa-los com um &.

Exemplo:

<param name="FlashVars" value="teste=funcionou!&teste2=hahaha..." />

Tabela do banco de dados para teste:

CREATE TABLE `usuario` (
`id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY ,
`email` VARCHAR( 50 ) NOT NULL ,
`login` VARCHAR( 20 ) NOT NULL ,
`senha` VARCHAR( 40 ) NOT NULL
) ;


Mas como usar a classe? Primeiro é preciso colocar um include da classe no arquivo php.

include("classeConexao.php");

Depois se passa os parâmetros host, user, pwd e bd, que no caso de estar testando a classe em um servidor local são: “localhost”, “root”, “” e “nomeDoBanco”.

$conexao = new Conexao($_host,$_user,$_pwd,$_db);
$conexao->conectar();

Para executar uma pesquisa sql:
$limite = $conexao->sql("SELECT * FROM usuario");

E para visualizar os resultados de login e email da consulta acima é preciso criar um loop:
while ($exibir = mysql_fetch_assoc($limite)) {
echo $exibir['login'] . " ". echo $exibir['email'];
}