<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="vertical" 
	backgroundColor="silver" backgroundImage=""
	applicationComplete="init()">
	<mx:Script>
		<![CDATA[
			import com.facebook.data.users.GetInfoData;
			import com.facebook.utils.FacebookSessionUtil;
			import com.facebook.data.users.FacebookUser;
			import com.facebook.data.users.GetInfoFieldValues;
			import com.facebook.commands.users.GetInfo;
			import com.facebook.net.FacebookCall;
			import com.facebook.events.FacebookEvent;
			import com.facebook.Facebook;
 
			private var fbook:Facebook;
			private var session:FacebookSessionUtil;
			private var user:FacebookUser;
 
			private function init():void{
				session=new FacebookSessionUtil("83ccead57ece4086338470a75e13c5b1","1fff6abf608e90e70e1aad07798aa8e4",loaderInfo);
				session.addEventListener(FacebookEvent.CONNECT,onConnect);
				fbook=session.facebook;
			}
			private function onLogin():void{
				this.removeChild(go_login);
				session.login();
			}
			private function onConfirmLogin():void{
				this.removeChild(loginbutton);
				session.validateLogin();
			}
			private function onConnect(e:FacebookEvent):void{
				var call:FacebookCall=fbook.post(new GetInfo([fbook.uid],[GetInfoFieldValues.ALL_VALUES]));
				call.addEventListener(FacebookEvent.COMPLETE,onGetInfo);
			}
			private function onGetInfo(e:FacebookEvent):void{
				user=(e.data as GetInfoData).userCollection.getItemAt(0) as FacebookUser;
				title.text="Hello "+user.first_name+" "+user.last_name+" born on "+user.birthday;
			}
		]]>
	</mx:Script>
 
	<mx:Label id="title" text="Facebook API test"/>
 
	<mx:Button id="go_login" label="Click here to login into Facebook" click="onLogin()"/>
	<mx:Button id="loginbutton" label="Click once logged into Facebook" click="onConfirmLogin()"/>
 
</mx:Application>

package br.com.pedrotaranto
{
	import flash.display.Sprite;
	import flash.display.StageAlign;
	import flash.display.StageScaleMode;
	import flash.events.MouseEvent;
	import flash.geom.Point;
 
	[SWF(backgroundColor = "#FFFFFF", width = '800', height = '600', frameRate = "30")]
	public class TiledMazeGen extends Sprite
	{
		//constants
		private const MAZE_WIDTH		: uint = 20;
		private const MAZE_HEIGHT		: uint = 20;
		private const TILE_SIZE			: uint = 10;
		private const START_COLOR		: uint = 0xFF0000;
		private const FINISH_COLOR		: uint = 0x00FF00;
		private const WALL_COLOR		: uint = 0x000000;
		private const WALKABLE_COLOR	: uint = 0xDDDDDD;
 
		//directions
		private const NORTH				: String = "N";
		private const SOUTH				: String = "S";
		private const EAST				: String = "E";
		private const WEST				: String = "W";
 
		//variables
		private var _width		: uint;
		private var _height		: uint;
		private var _maze		: Array;
		private var _moves		: Array;
		private var _start		: Point;
		private var _finish		: Point;
		private var _container	: Sprite;
 
		public function TiledMazeGen () : void
		{
			stage.align		= StageAlign.TOP_LEFT;
			stage.scaleMode	= StageScaleMode.NO_SCALE;
			stage.addEventListener(MouseEvent.CLICK, _generate);
 
			_width	= MAZE_WIDTH * 2 + 1;
			_height	= MAZE_HEIGHT * 2 + 1;
 
			_start	= new Point(1, 1);
			//_finish = new Point(_height - 2, _width - 2);
 
			_container = new Sprite();
 
			_generate();
		}
 
		private function _generate ( event : MouseEvent = null ) : void
		{
			_initMaze();
			_createMaze();
			_drawMaze();
		}
 
		private function _initMaze () : void
		{
			_maze	= new Array(_width);
 
			for ( var x : int = 0; x < _height; x++ )
			{
				_maze[x] = new Array(_height);
 
				for ( var y : int = 0; y < _width; y++ )
				{
					_maze[x][y] = true;
				}
			}
 
			_maze[_start.x][_start.y] = false;
		}
 
		private function _createMaze () : void
		{
			var back				: int;
			var move				: int;
			var possibleDirections	: String;
			var pos					: Point = _start.clone();
 
			_moves = new Array();
			_moves.push(pos.y + (pos.x * _width));
 
			while ( _moves.length )
			{
				possibleDirections = "";
 
				if ((pos.x + 2 < _height ) && (_maze[pos.x + 2][pos.y] == true) && (pos.x + 2 != false) && (pos.x + 2 != _height - 1) )
				{
					possibleDirections += SOUTH;
				}
 
				if ((pos.x - 2 >= 0 ) && (_maze[pos.x - 2][pos.y] == true) && (pos.x - 2 != false) && (pos.x - 2 != _height - 1) )
				{
					possibleDirections += NORTH;
				}
 
				if ((pos.y - 2 >= 0 ) && (_maze[pos.x][pos.y - 2] == true) && (pos.y - 2 != false) && (pos.y - 2 != _width - 1) )
				{
					possibleDirections += WEST;
				}
 
				if ((pos.y + 2 < _width ) && (_maze[pos.x][pos.y + 2] == true) && (pos.y + 2 != false) && (pos.y + 2 != _width - 1) )
				{
					possibleDirections += EAST;
				}
 
				if ( possibleDirections.length > 0 )
				{
					move = _randInt(0, (possibleDirections.length - 1));
 
					switch ( possibleDirections.charAt(move) )
					{
						case NORTH: 
							_maze[pos.x - 2][pos.y] = false;
							_maze[pos.x - 1][pos.y] = false;
							pos.x -=2;
							break;
 
						case SOUTH: 
							_maze[pos.x + 2][pos.y] = false;
							_maze[pos.x + 1][pos.y] = false;
							pos.x +=2;
							break;
 
						case WEST: 
							_maze[pos.x][pos.y - 2] = false;
							_maze[pos.x][pos.y - 1] = false;
							pos.y -=2;
							break;
 
						case EAST: 
							_maze[pos.x][pos.y + 2] = false;
							_maze[pos.x][pos.y + 1] = false;
							pos.y +=2;
							break;        
					}
 
					_moves.push(pos.y + (pos.x * _width));
				}
				else
				{
					back = _moves.pop();
					pos.x = int(back / _width);
					pos.y = back % _width;
				}
			}
		}
 
		private function _drawMaze () : void
		{
			var tile : Sprite;
 
			if ( contains(_container) )
			{
				removeChild(_container)
			}
 
			_container = new Sprite();
			addChild(_container);
 
			for ( var x : int = 0; x < _height; x++ )
			{
				for ( var y : int = 0; y < _width; y++ )
				{
					tile	= (_maze[x][y] == true) ? _drawTile(WALL_COLOR) : _drawTile(WALKABLE_COLOR);
					tile.x	= x * TILE_SIZE;
					tile.y	= y * TILE_SIZE;
 
					_container.addChild(tile);
				}
			}
 
			//start tile
			tile = _drawTile(START_COLOR);
			tile.x = _start.x * TILE_SIZE;
			tile.y = _start.y * TILE_SIZE;
			_container.addChild(tile);
 
			//finish tile
			/*tile = _drawTile(FINISH_COLOR);
			tile.x = _finish.x * TILE_SIZE;
			tile.y = _finish.y * TILE_SIZE;
			_container.addChild(tile);*/
		}
 
		private function _drawTile ( color : uint ) : Sprite
		{
			var tile : Sprite = new Sprite();
				tile.graphics.beginFill(color);
				tile.graphics.drawRect(0, 0, TILE_SIZE, TILE_SIZE);
				tile.graphics.endFill();
 
			return tile;
		}
 
		private function _randInt ( min : int, max : int ) : int 
		{
			return int((Math.random() * (max - min + 1)) + min);
		}
	}
}

package {
	import flash.display.Sprite;
	import flash.events.Event;
	import flash.events.KeyboardEvent;
 
	[SWF(width='500', height='400', frameRate='40', backgroundColor='0xffffff')]
	public class Platform extends Sprite
	{
		private var over:String = "";
		private var bonus_speed:Number = 0;
		private var press_left:Boolean = false;
		private var press_right:Boolean = false;
		private var press_up:Boolean = false;
		private var press_down:Boolean = false;
		private var press_space:Boolean = false;
		private var x_pos:Number = 0;
		private var y_pos:Number = 0;
		private var tile_size:Number = 20;
		private var ground_acceleration:Number = 1;
		private var ground_friction:Number = 0.8;
		private var air_acceleration:Number = 0.5;
		private var air_friction:Number = 0.7;
		private var ice_acceleration:Number = 0.15;
		private var ice_friction:Number = 0.95;
		private var treadmill_speed:Number = 2;
		private var max_speed:Number = 3;
		private var xspeed:Number = 0;
		private var yspeed:Number = 0;
		private var falling:Boolean = false;
		private var gravity:Number = 0.5;
		private var jump_speed:Number = 6;
		private var climbing:Boolean = false;
		private var climb_speed:Number = 0.8;
		private var coins:Array = new Array();
		private var level:Array = new Array();
		private var levelObj:Array = new Array
		private var keys:Array = new Array();
		private var player:Array = new Array();
		private var enemy:Array = new Array();
		private var walkable_tiles:Array = new Array(0, 5, 6, 7);
		private var h:hero = new hero();
		private var level_container:Sprite = new Sprite();
 
		private var bottom:Number;
		private var left:Number;
		private var right:Number;
		private var top:Number;
		private var bottom_left:Number;
		private var bottom_right:Number;
		private var top_left:Number;
		private var top_right:Number;
 
		private var climbdir:Number;
		private var current_tile:Number;
		private var friction:Number;
 
		private var speed:Number;
		private var jumping:Boolean;
		private var walking:Boolean;
		private var prev_bottom:Number;
 
		public function Platform()
		{
			level[0] = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
			level[1] = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1];
			level[2] = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 6, 1, 0, 0, 0, 0, 1];
			level[3] = [1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 1];
			level[4] = [1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 1];
			level[5] = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 1];
			level[6] = [1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 6, 1, 0, 0, 0, 0, 0, 1];
			level[7] = [1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 1];
			level[8] = [1, 1, 1, 1, 0, 9, 0, 0, 0, 5, 5, 0, 0, 0, 7, 0, 0, 6, 0, 0, 0, 0, 7, 0, 1];
			level[9] = [1, 1, 1, 1, 1, 1, 1, 2, 2, 8, 8, 8, 8, 1, 1, 3, 3, 1, 4, 4, 1, 8, 1, 8, 1];
 
			player = [4,8];
 
			coins[0] = [2, 2];
			coins[1] = [23, 4];
 
			enemy[0] = [10, 3, -2];
			enemy[1] = [3, 3, -2];
 
			keys[0] = [1, 5, 5, 8];
 
			create_level(level);
 
			addEventListener(Event.ENTER_FRAME,onEnterFrame);
			stage.addEventListener(KeyboardEvent.KEY_DOWN, key_down);
			stage.addEventListener(KeyboardEvent.KEY_UP, key_up);
		}
 
		public function key_down(event:KeyboardEvent):void
		{
			if (event.keyCode == 32)
			{
				press_space = true;
			}
 
			if (event.keyCode == 37)
			{
				press_left = true;
			}
 
			if (event.keyCode == 38)
			{
				press_up = true;
			}
 
			if (event.keyCode == 39)
			{
				press_right = true;
			}
 
			if (event.keyCode == 40)
			{
				press_down = true;
			}
		}
 
		public function key_up(event:KeyboardEvent):void
		{
			if (event.keyCode == 32)
			{
				press_space = false;
			}
 
			if (event.keyCode == 37)
			{
				press_left = false;
			}
 
			if (event.keyCode == 38)
			{
				press_up = false;
			}
 
			if (event.keyCode == 39)
			{
				press_right = false;
			}
 
			if (event.keyCode == 40)
			{
				press_down = false;
			}
		}
 
		public function create_level(l:Array):void
		{
			var level_height:Number = l.length;
			var level_width:Number = l[0].length;
 
			addChild(level_container);
 
			for (var j:Number = 0; j<level_height; j++)
			{
				levelObj[j] = new Array();
				for (var i:Number = 0; i<level_width; i++)
				{
					if (l[j][i] != 0)
					{
						var t:tile = new tile();
						t.x = i*tile_size;
						t.y = j*tile_size;
						t.gotoAndStop(l[j][i]);
						levelObj[j][i] = t;
						level_container.addChild(levelObj[j][i]);
					}
				}
			}
 
			place_player();
			level_container.addChild(h);
 
			for (var m:int = 0; m < coins.length; m++)
			{
				var c:coin = new coin();
				c.x = coins[m][0] * tile_size + tile_size / 2;
				c.y = coins[m][1] * tile_size + tile_size/2 + 1;
 
				coins[m] = c;
				level_container.addChild(coins[m]);
			}
 
			for (var n:int = 0; n < keys.length; n++)
			{
				var _k:key = new key();
				_k.x = keys[n][0] * tile_size + tile_size / 2;
				_k.y = keys[n][1] * tile_size + tile_size / 2 + 1;
				_k.openX = keys[n][2];
				_k.openY = keys[n][3];
				keys[n] = _k;
				level_container.addChild(keys[n]);
			}
 
			for (var k:int = 0; k < enemy.length; k++)
			{
				var foe:patrol = new patrol();
				foe.speed = enemy[k][2];
				foe.x = enemy[k][0] * tile_size + tile_size / 2;
				foe.y = enemy[k][1] * tile_size + tile_size / 2 + 1;
 
				enemy[k] = foe;
				level_container.addChild(enemy[k]);
			}
		}
 
		public function onEnterFrame(event:Event):void
		{
			ground_under_feet();
 
			walking = false;
			climbing = false;
			if (press_left) {
				xspeed-=speed;
				walking = true;
			}
			if (press_right) {
				xspeed += speed;
				walking = true;
			}
			if (press_up) {
				get_edges();
				if (top_right == 6 || bottom_right == 6 || top_left == 6 || bottom_left == 6) {
					jumping = false;
					falling = false;
					climbing = true;
					climbdir = -1;
				}
			}
			if (press_down) {
				get_edges();
				if (over == "ladder" || top_right == 6 || bottom_right == 6 || top_left == 6 || bottom_left == 6) {
					jumping = false;
					falling = false;
					climbing = true;
					climbdir = 1;
				}
			}
			if (press_space) {
				get_edges();
				if (!falling && !jumping) {
					jumping = true;
					yspeed = -jump_speed;
				}
			}
			if (!walking) {
				xspeed *= friction;
				if (Math.abs(xspeed)<0.5) {
					xspeed = 0;
				}
			}
			if (xspeed>max_speed) {
				xspeed = max_speed;
			}
			if (xspeed<max_speed*-1) {
				xspeed = max_speed*-1;
			}
			if (falling || jumping) {
				yspeed += gravity;
			}
			if (climbing) {
				yspeed = climb_speed*climbdir;
			}
			if (!falling && !jumping && !climbing) {
				yspeed = 0;
			}
			xspeed += bonus_speed;
			check_collisions();
			h.x = x_pos;
			h.y = y_pos;
 
			level_container.x = -x_pos + 250;
			level_container.y = -y_pos + 200;
 
			xspeed -= bonus_speed;
 
			for (var i:int = 0; i < enemy.length; i++)
			{
				enemy[i].x_pos = enemy[i].x;
				enemy[i].y_pos = enemy[i].y;
 
				enemy[i].x_pos += enemy[i].speed;
 
				enemy[i].left_foot_x = Math.floor((enemy[i].x_pos-6)/tile_size);
				enemy[i].right_foot_x = Math.floor((enemy[i].x_pos+5)/tile_size);
				enemy[i].foot_y = Math.floor((enemy[i].y_pos+9)/tile_size);
				enemy[i].bottom = Math.floor((enemy[i].y_pos+8)/tile_size);
				enemy[i].left_foot = level[enemy[i].foot_y][enemy[i].left_foot_x];
				enemy[i].right_foot = level[enemy[i].foot_y][enemy[i].right_foot_x];
				enemy[i].left = level[enemy[i].bottom][enemy[i].left_foot_x];
				enemy[i].right = level[enemy[i].bottom][enemy[i].right_foot_x];
 
				if (enemy[i].left_foot != 0 && enemy[i].right_foot != 0 && enemy[i].left == 0 && enemy[i].right == 0)
				{
					enemy[i].x = enemy[i].x_pos;
				}
				else {
					enemy[i].speed *= -1;
				}
			}
 
			for (var j:int = 0; j < coins.length; j++)
			{
				if(coins[j].hitTestObject(h))
				{
					level_container.removeChild(coins[j]);
				}
			}
 
			for (var k:int = 0; k < keys.length; k++)
			{
				if(keys[k].hitTestObject(h))
				{
					level[keys[k].openY][keys[k].openX] = 0;
 
					level_container.removeChild(levelObj[keys[k].openY][keys[k].openX]);
					level_container.removeChild(keys[k]);
				}
			}
		}
 
		public function ground_under_feet():void
		{
			bonus_speed = 0;
			var left_foot_x:Number = Math.floor((x_pos-6)/tile_size);
			var right_foot_x:Number = Math.floor((x_pos+5)/tile_size);
			var foot_y:Number = Math.floor((y_pos+9)/tile_size);
			var left_foot:Number = level[foot_y][left_foot_x];
			var right_foot:Number = level[foot_y][right_foot_x];
			if (left_foot != 0) {
				current_tile = left_foot;
			} else {
				current_tile = right_foot;
			}
			switch (current_tile) {
				case 0 :
					speed = air_acceleration;
					friction = air_friction;
					falling = true;
					break;
				case 1 :
					over = "ground";
					speed = ground_acceleration;
					friction = ground_friction;
					break;
				case 2 :
					over = "ice";
					speed = ice_acceleration;
					friction = ice_friction;
					break;
				case 3 :
					over = "treadmill";
					speed = ground_acceleration;
					friction = ground_friction;
					bonus_speed = -treadmill_speed;
					break;
				case 4 :
					over = "treadmill";
					speed = ground_acceleration;
					friction = ground_friction;
					bonus_speed = treadmill_speed;
					break;
				case 5 :
					over = "cloud";
					speed = ground_acceleration;
					friction = ground_friction;
					break;
				case 6 :
					over = "ladder";
					speed = ground_acceleration;
					friction = ground_friction;
					break;
 
				case 7 :
					over = "trampoline";
					speed = ground_acceleration;
					friction = ground_friction;
					break;
				case 8 :
					over = "spikes";
					if (left_foot == 8 && right_foot == 8)
					{
						place_player();
					}
			}
		}
 
		public function check_collisions():void
		{
			y_pos += yspeed;
			get_edges();
 
			if (yspeed>0) {
				if ((bottom_right != 0 && bottom_right != 6) || (bottom_left != 0 && bottom_left != 6)) {
					if (bottom_right != 5 && bottom_left != 5) {
						if ((bottom_right == 7 || bottom_left == 7) && (Math.abs(yspeed)>1))
						{
							// trampoline
                    		yspeed *= -1;
                    		jumping = true;
                    		falling = true;
						}else {
							y_pos = bottom*tile_size-9;
							yspeed = 0;
							falling = false;
							jumping = false;
						}
					} else {
						if (prev_bottom<bottom) {
							y_pos = bottom*tile_size-9;
							yspeed = 0;
							falling = false;
							jumping = false;
						}
					}
				}
			}
 
			if (yspeed<0) {
				if ((top_right != 0 && top_right != 5 && top_right != 6) || (top_left != 0 && top_left != 5 && top_left != 6)) {
					y_pos = bottom*tile_size+1+8;
					yspeed = 0;
					falling = false;
					jumping = false;
				}
			}
			x_pos += xspeed;
			get_edges();
 
			if (xspeed < 0) {
				if (!is_walkable(top_left) || !is_walkable(bottom_left)) {
					x_pos = (left + 1) * tile_size + 6;
					xspeed = 0;
				}
			}
 
			if (xspeed>0) {
				if (!is_walkable(top_right) || !is_walkable(bottom_right)) {
					x_pos = right * tile_size - 6;
					xspeed = 0;
				}
			}
 
			prev_bottom = bottom;
		}
 
		public function get_edges():void
		{
			right = Math.floor((x_pos+5)/tile_size);
			left = Math.floor((x_pos-6)/tile_size);
			bottom = Math.floor((y_pos+8)/tile_size);
			top = Math.floor((y_pos-9)/tile_size);
 
			top_right = level[top][right];
			top_left = level[top][left];
			bottom_left = level[bottom][left];
			bottom_right = level[bottom][right];
		}
 
		public function place_player():void
		{
			x_pos = (player[0] * tile_size) + (tile_size / 2);
			y_pos = (player[1] * tile_size) + (tile_size / 2 + 1);
 
			h.x = x_pos;
			h.y = y_pos;
		}
 
		public function is_walkable(tile:int):Boolean {
			var walkable:Boolean = false;
			for (var i:int = 0; i < walkable_tiles.length; i++)
			{
				if (tile == walkable_tiles[i])
				{
					walkable = true;
					break;
				}
			}
 
			return (walkable);
		}
	}
}

package {
	import flash.display.Sprite;
 
	public class ape extends Sprite
	{
		public function ape()
		{
		}
	}
}

package {
	import org.cove.ape.*;
	import flash.events.Event;
	import flash.display.Sprite;  
	[SWF(width='500',height='400',backgroundColor='0xFFFFFF',frameRate='30')]
	public class ape extends Sprite {
		public function ape() {
			addEventListener(Event.ENTER_FRAME, run);
			APEngine.init(1/4);
			APEngine.container = this;
			APEngine.addMasslessForce(new Vector(0,2));
			var defaultGroup:Group = new Group();
			defaultGroup.collideInternal = true;			
			var cp:CircleParticle = new CircleParticle(250,10,5);
			defaultGroup.addParticle(cp);         	
         	var wp:WheelParticle = new WheelParticle(280,10,5,false,1,0.3,0.1,1);
			defaultGroup.addParticle(wp);
			var rp:RectangleParticle = new RectangleParticle(250,300,200,10,-0.52,true);
			defaultGroup.addParticle(rp);      
			var rp2:RectangleParticle = new RectangleParticle(150,200,200,10,0.52,true);
			defaultGroup.addParticle(rp2);        
			var rp3:RectangleParticle = new RectangleParticle(250,50,200,10,-0.52,true);
			defaultGroup.addParticle(rp3);
			var wa: WheelParticle = new WheelParticle(160,20,10,false,2);
			defaultGroup.addParticle(wa);		
			var wb: WheelParticle = new WheelParticle(200,20,10,false,2)
			defaultGroup.addParticle(wb);		
			var wc:SpringConstraint = new SpringConstraint(wa, wb, 0.5, true, 3);
			defaultGroup.addConstraint(wc);       	
        	APEngine.addGroup(defaultGroup);
		}
		private function run(evt:Event):void {
			APEngine.step();
			APEngine.paint();
		}
	}
}