private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.ADMIN_MESSAGE, onAdminMessage);
             
             // Set the message recipients: all users in the Zone
             var recipMode:MessageRecipientMode = new MessageRecipientMode(MessageRecipientMode.TO_ZONE, null);
             
             // Send the administrator message
             sfs.send(new AdminMessageRequest("Hello to everybody from the Administrator!", recipMode));
         }
         
         private function onAdminMessage(evt:SFSEvent):void
         {
             trace("The administrator sent the following message: " + evt.params.message);
         }
         

         
         private function someMethod():void
         {
             var sfs:SmartFox = new SmartFox();
             
             sfs.addEventListener(SFSEvent.CONFIG_LOAD_SUCCESS, onConfigLoaded);
             sfs.addEventListener(SFSEvent.CONFIG_LOAD_FAILURE, onConfigLoadFailed);
             
             sfs.loadConfig("testConfig.xml", false);
         }
         
         private function onConfigLoaded(evt:SFSEvent):void
         {
             // Configuration loaded successfully, now connect
             sfs.connect();
         }
         
         private function onConfigLoadFailed(evt:SFSEvent):void
         {
             trace("Failed loading configuration file");
         }
         

         
         private function someMethod():void
         {
             var sfs:SmartFox = new SmartFox();
             sfs.addEventListener(SFSEvent.CONNECTION, onConnection);
             
             sfs.connect();
         }
         
         private function onConnection(evt:SFSEvent):void
         {
             if (evt.params.success)
                 trace("Connection established");
             else
                 trace("Connection failed");
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.CONNECTION_LOST, onConnectionLost);
         }
         
         private function onConnectionLost(evt:SFSEvent):void
         {
             var reason:String = evt.params.reason;
             
             if (reason != ClientDisconnectionReason.MANUAL)
             {
                 if (reason == ClientDisconnectionReason.IDLE)
                     trace("A disconnection occurred due to inactivity");
                 else if (reason == ClientDisconnectionReason.KICK)
                     trace("You have been kicked by the moderator");
                 else if (reason == ClientDisconnectionReason.BAN)
                     trace("You have been banned by the moderator");
                 else
                     trace("A disconnection occurred due to unknown reason; please check the server log");
             }
             else
             {
                 // Manual disconnection is usually ignored
             }
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.CONNECTION_RETRY, onConnectionRetry);
             sfs.addEventListener(SFSEvent.CONNECTION_RESUME, onConnectionResumed);
             sfs.addEventListener(SFSEvent.CONNECTION_LOST, onConnectionLost);
         }
         
         private function onConnectionRetry(evt:SFSEvent):void
         {
             // Freeze the GUI and provide some feedback to the player
             ...
         }
         
         private function onConnectionResumed(evt:SFSEvent):void
         {
             // Unfreeze the GUI and let the player continue with the game
             ...
         }
         
         private function onConnectionLost(evt:SFSEvent):void
         {
             trace("Ouch, connection was lost. Reason: " + evt.params.reason);
         }
         

         var sfs:SmartFox = new SmartFox();
         sfs.addEventListener(SFSEvent.CONNECTION, onConnect);
         sfs.addEventListener(SFSEvent.CRYPTO_INIT, onCryptInit);
         
         sfs.connect("mysecuredomain.com", 9933);
         
         function onConnect(evt:SFSEvent):void
         {
             if (evt.param.success)
                 sfs.initCrypto();
                 
             else
                 trace("Sorry, connection failed");
         }
         
         function onCryptInit(evt:SFSEvent):void
         {
             ta_data.text = evt.params.success;
             
             if (evt.params.success)
                 sfs.send(new LoginRequest("MyName", "MyPassword", "MyZone"));
         
             else
                 trace("Crypto init failed. Caused by: " + evt.params.errorMsg)
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.EXTENSION_RESPONSE, onExtensionResponse);
             
             // Send two integers to the Zone extension and get their sum in return
             var params:ISFSObject = new SFSObject();
             params.putInt("n1", 26);
             params.putInt("n2", 16);
             
             sfs.send(new ExtensionRequest("add", params));
         }
         
         private function onExtensionResponse(evt:SFSEvent):void
         {
             if (evt.params.cmd == "add")
             {
                 var responseParams:ISFSObject = evt.params.params as SFSObject;
                 
                 // We expect an int parameter called "sum"
                 trace("The sum is: " + responseParams.getInt("sum"));
             }
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.INVITATION, onInvitationReceived);
             sfs.addEventListener(SFSEvent.INVITATION_REPLY_ERROR, onInvitationReplyError);
         }
         
         private function onInvitationReceived(evt:SFSEvent):void
         {
             // Let's accept this invitation            
             sfs.send(new InvitationReplyRequest(evt.params.invitation, InvitationReply.ACCEPT));
         }
         
         private function onInvitationReplyError(evt:SFSEvent):void
         {
             trace("Failed to reply to invitation due to the following problem: " + evt.params.errorMessage);
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.LOGIN, onLogin);
             sfs.addEventListener(SFSEvent.LOGIN_ERROR, onLoginError);
             
             // Login
             sfs.send(new LoginRequest("FozzieTheBear", "", "SimpleChat"));
         }
         
         private function onLogin(evt:SFSEvent):void
         {
             trace("Login successful!");
         }
         
         private function onLoginError(evt:SFSEvent):void
         {
             trace("Login failure: " + evt.params.errorMessage);
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.LOGOUT, onLogout);
             
             // Logout
             sfs.send(new LogoutRequest());
         }
         
         private function onLogout(evt:SFSEvent):void
         {
             trace("Logout executed!");
         }
         

                  private function onMMOItemVarsUpdate(evt:SFSEvent):void
         {
             var changedVars:Array = evt.params.changedVars;
             var item:IMMOItem = evt.params.mmoItem;
             
             // Check if the MMOItem was moved 
             if (changedVars.indexOf("x") != -1 || changedVars.indexOf("y") != -1)
             {
                 // Move the sprite representing the MMOItem on the stage
                 ...
             }
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.MODERATOR_MESSAGE, onModeratorMessage);
             
             // Set the message recipients: all users in the current Room
             var recipMode:MessageRecipientMode = new MessageRecipientMode(MessageRecipientMode.TO_ROOM, sfs.lastJoinedRoom);
             
             // Send the moderator message
             sfs.send(new ModeratorMessageRequest("Hello everybody, I'm the Moderator!", recipMode));
         }
         
         private function onModeratorMessage(evt:SFSEvent):void
         {
             trace("The moderator sent the following message: " + evt.params.message);
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.OBJECT_MESSAGE, onObjectMessage);
             
             // Send my movement to all players
             var dataObj:ISFSObject = new SFSObject();
             dataObj.putInt("x", myCharacter.x);
             dataObj.putInt("y", myCharacter.y);
             
             sfs.send(new ObjectMessageRequest(dataObj));
         }
         
         private function onObjectMessage(evt:SFSEvent):void
         {
             var dataObj:ISFSObject = evt.params.message as SFSObject;
             
             var sender:User = evt.params.sender;
             var character:Sprite = getUserCharacter(sender.id);
             
             character.x = dataObj.getInt("x");
             character.y = dataObj.getInt("y");
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.PLAYER_TO_SPECTATOR, onPlayerToSpectatorSwitch);
             sfs.addEventListener(SFSEvent.PLAYER_TO_SPECTATOR_ERROR, onPlayerToSpectatorSwitchError);
             
             // Switch player to spectator
             sfs.send(new PlayerToSpectatorRequest());
         }
         
         private function onPlayerToSpectatorSwitch(evt:SFSEvent):void
         {
             trace("Player " + evt.params.user + " is now a spectator");
         }
         
         private function onPlayerToSpectatorSwitchError(evt:SFSEvent):void
         {
             trace("Unable to become a spectator due to the following error: " + evt.params.errorMessage);
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.PRIVATE_MESSAGE, onPrivateMessage);
             
             // Send a private message to Jack
             var user:User = sfs.usermanager.getUserByName("Jack");
             sfs.send(new PrivateMessageRequest("Hello my friend!", user.id));
         }
         
         private function onPrivateMessage(evt:SFSEvent):void
         {
             // As messages are forwarded to the sender too,
             // I have to check if I am the sender
             
             var sender:User = evt.params.sender;
             
             if (sender != sfs.mySelf)
                 trace("User " + sender.name + " sent me this PM:", evt.params.message);
         }
         

         
         private function onProximityListUpdate(evt:SFSEvent):void
         {
             var added:Array = evt.params.addedUsers;
             var removed:Array = evt.params.removedUsers;
         
             // Add users that entered the proximity list
             for each (var user:User in added)
             {
                 // Obtain the coordinates at which the user "appeared" in our range
                 var entryPoint:Vec3D = user.aoiEntryPoint;
             
                 // Add new avatar on screen
                 var avatarSprite:AvatarSprite = new AvatarSprite();
                 avatarSprite.x = entryPoint.px;
                 avatarSprite.y = entryPoint.py;
                 ...
             }
         
             // Remove users that left the proximity list
             for each (var user:User in removed)
             {
                 // Remove the avatar from stage
                 ...
             }
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.PUBLIC_MESSAGE, onPublicMessage);
             
             // Send a public message
             sfs.send(new PublicMessageRequest("Hello everyone!"));
         }
         
         private function onPublicMessage(evt:SFSEvent):void
         {
             // As messages are forwarded to the sender too,
             // I have to check if I am the sender
             
             var sender:User = evt.params.sender;
             
             if (sender == sfs.mySelf)
                 trace("I said:", evt.params.message);
             else
                 trace("User " + sender.name + " said:", evt.params.message);
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.ROOM_ADD, onRoomCreated);
             sfs.addEventListener(SFSEvent.ROOM_CREATION_ERROR, onRoomCreationError);
             
             // Define the settings of a new chat Room
             var settings:RoomSettings = new RoomSettings("My Chat Room");
             settings.maxUsers = 40;
             settings.groupId = "chats";
             
             // Create the Room
             sfs.send(new CreateRoomRequest(settings));
         }
         
         private function onRoomCreated(evt:SFSEvent):void
         {
             trace("Room created: " + evt.params.room);
         }
         
         private function onRoomCreationError(evt:SFSEvent):void
         {
             trace("Room creation failure: " + evt.params.errorMessage);
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.ROOM_CAPACITY_CHANGE, onRoomCapacityChanged);
             sfs.addEventListener(SFSEvent.ROOM_CAPACITY_CHANGE_ERROR, onRoomCapacityChangeError);
             
             var theRoom:Room = sfs.getRoomByName("Gonzo's Room");
             
             // Resize the Room so that it allows a maximum of 100 users and zero spectators
             sfs.send(new ChangeRoomCapacityRequest(theRoom, 100, 0));
         }
         
         private function onRoomCapacityChanged(evt:SFSEvent):void
         {
             trace("The capacity of Room " + evt.params.room.name + " was changed successfully");
         }
         
         private function onRoomCapacityChangeError(evt:SFSEvent):void
         {
             trace("Room capacity change failed: " + evt.params.errorMessage);
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.ROOM_FIND_RESULT, onRoomFindResult);
             
             // Create a matching expression to find Rooms with a "country" variable equal to "Sweden"
             var exp:MatchExpression = new MatchExpression("country", StringMatch.EQUALS, "Sweden");
             
             // Find the Rooms
             sfs.send(new FindRoomRequest(exp));
         }
         
         private function onRoomFindResult(evt:SFSEvent):void
         {
             trace("Rooms found: " + evt.params.rooms);
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.ROOM_GROUP_SUBSCRIBE, onGroupSubscribed);
             sfs.addEventListener(SFSEvent.ROOM_GROUP_SUBSCRIBE_ERROR, onGroupSubscribeError);
             
             // Subscribe the "cardGames" group
             sfs.send(new SubscribeRoomGroupRequest("cardGames"));
         }
         
         private function onGroupSubscribed(evt:SFSEvent):void
         {
             trace("Group subscribed. The following rooms are now accessible: " + evt.params.newRooms);
         }
         
         private function onGroupSubscribeError(evt:SFSEvent):void
         {
             trace("Group subscription failed: " + evt.params.errorMessage);
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.ROOM_GROUP_UNSUBSCRIBE, onGroupUnsubscribed);
             sfs.addEventListener(SFSEvent.ROOM_GROUP_UNSUBSCRIBE_ERROR, onGroupUnsubscribeError);
             
             // Unsubscribe the "cardGames" group
             sfs.send(new UnsubscribeRoomGroupRequest("cardGames"));
         }
         
         private function onGroupUnsubscribed(evt:SFSEvent):void
         {
             trace("Group unsubscribed: " + evt.params.groupId);
         }
         
         private function onGroupUnsubscribeError(evt:SFSEvent):void
         {
             trace("Group unsubscribing failed: " + evt.params.errorMessage);
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.ROOM_JOIN, onRoomJoined);
             sfs.addEventListener(SFSEvent.ROOM_JOIN_ERROR, onRoomJoinError);
             
             // Join a Room called "Lobby"
             sfs.send(new JoinRoomRequest("Lobby"));
         }
         
         private function onRoomJoined(evt:SFSEvent):void
         {
             trace("Room joined successfully: " + evt.params.room);
         }
         
         private function onRoomJoinError(evt:SFSEvent):void
         {
             trace("Room joining failed: " + evt.params.errorMessage);
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.ROOM_NAME_CHANGE, onRoomNameChanged);
             sfs.addEventListener(SFSEvent.ROOM_NAME_CHANGE_ERROR, onRoomNameChangeError);
             
             var theRoom:Room = sfs.getRoomByName("Gonzo's Room");
             sfs.send(new ChangeRoomNameRequest(theRoom, "Gonzo The Great's Room"));
         }
         
         private function onRoomNameChanged(evt:SFSEvent):void
         {
             trace("Room " + evt.params.oldName + " was successfully renamed to " + evt.params.room.name);
         }
         
         private function onRoomNameChangeError(evt:SFSEvent):void
         {
             trace("Room name change failed: " + evt.params.errorMessage);
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.ROOM_PASSWORD_STATE_CHANGE, onRoomPasswordStateChanged);
             sfs.addEventListener(SFSEvent.ROOM_PASSWORD_STATE_CHANGE_ERROR, onRoomPasswordStateChangeError);
             
             var theRoom:Room = sfs.getRoomByName("Gonzo's Room");
             sfs.send(new ChangeRoomPasswordStateRequest(theRoom, "mammamia"));
         }
         
         private function onRoomPasswordStateChanged(evt:SFSEvent):void
         {
             trace("The password of Room " + evt.params.room.name + " was changed successfully");
         }
         
         private function onRoomPasswordStateChangeError(evt:SFSEvent):void
         {
             trace("Room password change failed: " + evt.params.errorMessage);
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.ROOM_REMOVE, onRoomRemoved);
         }
         
         private function onRoomRemoved(evt:SFSEvent):void
         {
             trace("The following Room was removed: " + evt.params.room);
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.ROOM_VARIABLES_UPDATE, onRoomVarsUpdate);
             
             // Create some Room Variables
             var roomVars:Array = [];
             roomVars.push(new SFSRoomVariable("gameStarted", false));
             roomVars.push(new SFSRoomVariable("gameType", "Snooker"));
             roomVars.push(new SFSRoomVariable("minRank", 10));
             
             sfs.send(new SetRoomVariablesRequest(roomVars));
         }
         
         private function onRoomVarsUpdate(evt:SFSEvent):void
         {
             var changedVars:Array = evt.params.changedVars as Array;
             var room:Room = evt.params.room as Room;
             
             // Check if the "gameStarted" variable was changed
             if (changedVars.indexOf("gameStarted") != -1)
             {
                 if (room.getVariable("gameStarted").getBoolValue() == true)
                     trace("Game started");
                 else
                     trace("Game stopped");
             }
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.SPECTATOR_TO_PLAYER, onSpectatorToPlayerSwitch);
             sfs.addEventListener(SFSEvent.SPECTATOR_TO_PLAYER_ERROR, onSpectatorToPlayerSwitchError);
             
             // Switch spectator to player
             sfs.send(new SpectatorToPlayerRequest());
         }
         
         private function onSpectatorToPlayerSwitch(evt:SFSEvent):void
         {
             trace("Spectator " + evt.params.user + " is now a player");
         }
         
         private function onSpectatorToPlayerSwitchError(evt:SFSEvent):void
         {
             trace("Unable to become a player due to the following error: " + evt.params.errorMessage);
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.UDP_INIT, onUDPInit);
             
             sfs.initUDP(new AirUDPManager());
         }
         
         private function onUDPInit(evt:SFSEvent):void
         {
             if (evt.params.success)
             {
                 // Connection successful: execute an Extension call via UDP
                 sfs.send( new ExtensionRequest("udpTest", new SFSObject(), null, true) );
             }
             else
             {
                 trace("UDP initialization failed!");
             }
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.USER_COUNT_CHANGE, onUserCountChanged);
         }
         
         private function onUserCountChanged(evt:SFSEvent):void
         {
             var room:Room = evt.params.room;
             var uCount:int = evt.params.uCount;
             var sCount:int = evt.params.sCount;
             
             trace("Room: " + room.name + " now contains " + uCount + " users and " + sCount + " spectators");
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.USER_ENTER_ROOM, onUserEnterRoom);
         }
         
         private function onUserEnterRoom(evt:SFSEvent):void
         {
             var room:Room = evt.params.room;
             var user:User = evt.params.user;
             
             trace("User " + user.name + " just joined Room " + room.name);
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.USER_EXIT_ROOM, onUserExitRoom);
         }
         
         private function onUserExitRoom(evt:SFSEvent):void
         {
             var room:Room = evt.params.room;
             var user:User = evt.params.user;
             
             trace("User " + user.name + " just left Room " + room.name);
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.USER_FIND_RESULT, onUserFindResult);
             
             // Create a matching expression to find users with an "age" variable greater than 29:
             var exp:MatchExpression = new MatchExpression("age", NumberMatch.GREATER_THAN, 29);
             
             // Find the users
             sfs.send(new FindUserRequest(exp));
         }
         
         private function onUserFindResult(evt:SFSEvent):void
         {
             trace("Users found: " + evt.params.users);
         }
         

         
         private function someMethod():void
         {
             sfs.addEventListener(SFSEvent.USER_VARIABLES_UPDATE, onUserVarsUpdate);
             
             // Create some User Variables
             var userVars:Array = [];
             userVars.push(new SFSUserVariable("avatarType", "SwedishCook"));
             userVars.push(new SFSUserVariable("country", "Sweden"));
             userVars.push(new SFSUserVariable("x", 10));
             userVars.push(new SFSUserVariable("y", 5));
             
             sfs.send(new SetUserVariablesRequest(userVars));
         }
         
         private function onUserVarsUpdate(evt:SFSEvent):void
         {
             var changedVars:Array = evt.params.changedVars as Array;
             var user:User = evt.params.user as User;
             
             // Check if the user changed his x and y user variables
             if (changedVars.indexOf("x") != -1 || changedVars.indexOf("y") != -1)
             {
                 // Move the user avatar to a new position
                 ...
             }
         }