home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Puzzle / Clusterz / Clusterz.swf / scripts / it / gotoandplay / smartfoxserver / SmartFoxClient.as < prev   
Encoding:
Text File  |  2008-09-12  |  27.0 KB  |  889 lines
  1. package it.gotoandplay.smartfoxserver
  2. {
  3.    import flash.events.ErrorEvent;
  4.    import flash.events.Event;
  5.    import flash.events.EventDispatcher;
  6.    import flash.events.IOErrorEvent;
  7.    import flash.events.ProgressEvent;
  8.    import flash.events.SecurityErrorEvent;
  9.    import flash.net.Socket;
  10.    import flash.utils.ByteArray;
  11.    import flash.utils.getTimer;
  12.    import it.gotoandplay.smartfoxserver.data.Room;
  13.    import it.gotoandplay.smartfoxserver.data.User;
  14.    import it.gotoandplay.smartfoxserver.handlers.ExtHandler;
  15.    import it.gotoandplay.smartfoxserver.handlers.IMessageHandler;
  16.    import it.gotoandplay.smartfoxserver.handlers.SysHandler;
  17.    import it.gotoandplay.smartfoxserver.json.JSON;
  18.    import it.gotoandplay.smartfoxserver.util.Entities;
  19.    import it.gotoandplay.smartfoxserver.util.ObjectSerializer;
  20.    
  21.    public class SmartFoxClient extends EventDispatcher
  22.    {
  23.       
  24.       private static const EOM:int = 0;
  25.       
  26.       private static const MSG_JSON:String = "{";
  27.       
  28.       public static const XTMSG_TYPE_STR:String = "str";
  29.       
  30.       public static const MODMSG_TO_USER:String = "u";
  31.       
  32.       public static const MODMSG_TO_ZONE:String = "z";
  33.       
  34.       private static const MSG_STR:String = "%";
  35.       
  36.       private static const MSG_XML:String = "<";
  37.       
  38.       public static const XTMSG_TYPE_JSON:String = "json";
  39.       
  40.       public static const XTMSG_TYPE_XML:String = "xml";
  41.       
  42.       public static const MODMSG_TO_ROOM:String = "r";
  43.        
  44.       
  45.       private var connected:Boolean;
  46.       
  47.       private var benchStartTime:int;
  48.       
  49.       public var myUserId:int;
  50.       
  51.       private var roomList:Array;
  52.       
  53.       private var minVersion:Number;
  54.       
  55.       public var buddyVars:Array;
  56.       
  57.       public var debug:Boolean;
  58.       
  59.       private var byteBuffer:ByteArray;
  60.       
  61.       private var subVersion:Number;
  62.       
  63.       public var buddyList:Array;
  64.       
  65.       private var messageHandlers:Array;
  66.       
  67.       private var majVersion:Number;
  68.       
  69.       private var socketConnection:Socket;
  70.       
  71.       private var sysHandler:SysHandler;
  72.       
  73.       public var myUserName:String;
  74.       
  75.       public var playerId:int;
  76.       
  77.       public var amIModerator:Boolean;
  78.       
  79.       public var changingRoom:Boolean;
  80.       
  81.       private var extHandler:ExtHandler;
  82.       
  83.       public var activeRoomId:int;
  84.       
  85.       public function SmartFoxClient(param1:Boolean = false)
  86.       {
  87.          super();
  88.          this.majVersion = 1;
  89.          this.minVersion = 3;
  90.          this.subVersion = 4;
  91.          this.activeRoomId = -1;
  92.          this.debug = param1;
  93.          this.messageHandlers = [];
  94.          setupMessageHandlers();
  95.          socketConnection = new Socket();
  96.          socketConnection.addEventListener(Event.CONNECT,handleSocketConnection);
  97.          socketConnection.addEventListener(Event.CLOSE,handleSocketDisconnection);
  98.          socketConnection.addEventListener(ErrorEvent.ERROR,handleSocketError);
  99.          socketConnection.addEventListener(IOErrorEvent.IO_ERROR,handleIOError);
  100.          socketConnection.addEventListener(ProgressEvent.SOCKET_DATA,handleSocketData);
  101.          socketConnection.addEventListener(SecurityErrorEvent.SECURITY_ERROR,handleSecurityError);
  102.          byteBuffer = new ByteArray();
  103.       }
  104.       
  105.       private function getXmlUserVariable(param1:Object) : String
  106.       {
  107.          var _loc2_:String = null;
  108.          var _loc3_:* = undefined;
  109.          var _loc4_:String = null;
  110.          var _loc5_:* = null;
  111.          var _loc6_:String = null;
  112.          _loc2_ = "<vars>";
  113.          for(_loc6_ in param1)
  114.          {
  115.             _loc3_ = param1[_loc6_];
  116.             if((_loc5_ = typeof _loc3_) == "boolean")
  117.             {
  118.                _loc4_ = "b";
  119.                _loc3_ = !!_loc3_ ? "1" : "0";
  120.             }
  121.             else if(_loc5_ == "number")
  122.             {
  123.                _loc4_ = "n";
  124.             }
  125.             else if(_loc5_ == "string")
  126.             {
  127.                _loc4_ = "s";
  128.             }
  129.             else if(_loc5_ == "null")
  130.             {
  131.                _loc4_ = "x";
  132.             }
  133.             if(_loc4_ != null)
  134.             {
  135.                _loc2_ += "<var n=\'" + _loc6_ + "\' t=\'" + _loc4_ + "\'><![CDATA[" + _loc3_ + "]]></var>";
  136.             }
  137.          }
  138.          return _loc2_ + "</vars>";
  139.       }
  140.       
  141.       private function checkBuddyDuplicates(param1:String) : Boolean
  142.       {
  143.          var _loc2_:Boolean = false;
  144.          var _loc3_:Object = null;
  145.          _loc2_ = false;
  146.          for each(_loc3_ in buddyList)
  147.          {
  148.             if(_loc3_.name == param1)
  149.             {
  150.                _loc2_ = true;
  151.                break;
  152.             }
  153.          }
  154.          return _loc2_;
  155.       }
  156.       
  157.       public function getBuddyRoom(param1:Object) : void
  158.       {
  159.          if(param1.id != -1)
  160.          {
  161.             send({
  162.                "t":"sys",
  163.                "bid":param1.id
  164.             },"roomB",-1,"<b id=\'" + param1.id + "\' />");
  165.          }
  166.       }
  167.       
  168.       private function handleSocketData(param1:Event) : void
  169.       {
  170.          var _loc2_:int = 0;
  171.          var _loc3_:int = 0;
  172.          _loc2_ = int(socketConnection.bytesAvailable);
  173.          while(--_loc2_ >= 0)
  174.          {
  175.             _loc3_ = socketConnection.readByte();
  176.             if(_loc3_ != 0)
  177.             {
  178.                byteBuffer.writeByte(_loc3_);
  179.             }
  180.             else
  181.             {
  182.                handleMessage(byteBuffer.toString());
  183.                byteBuffer = new ByteArray();
  184.             }
  185.          }
  186.       }
  187.       
  188.       private function handleSocketError(param1:Event) : void
  189.       {
  190.          trace("SOCKET ERROR!!!");
  191.       }
  192.       
  193.       private function getXmlRoomVariable(param1:Object) : String
  194.       {
  195.          var _loc2_:String = null;
  196.          var _loc3_:* = undefined;
  197.          var _loc4_:String = null;
  198.          var _loc5_:String = null;
  199.          var _loc6_:String = null;
  200.          _loc2_ = String(param1.name.toString());
  201.          _loc3_ = param1.val.toString();
  202.          _loc4_ = !!param1.priv ? "1" : "0";
  203.          _loc5_ = !!param1.persistent ? "1" : "0";
  204.          _loc6_ = null;
  205.          if(typeof _loc3_ == "boolean")
  206.          {
  207.             _loc6_ = "b";
  208.             _loc3_ = !!_loc3_ ? "1" : "0";
  209.          }
  210.          else if(typeof _loc3_ == "number")
  211.          {
  212.             _loc6_ = "n";
  213.          }
  214.          else if(typeof _loc3_ == "string")
  215.          {
  216.             _loc6_ = "s";
  217.          }
  218.          else if(typeof _loc3_ == "null")
  219.          {
  220.             _loc6_ = "x";
  221.          }
  222.          if(_loc6_ != null)
  223.          {
  224.             return "<var n=\'" + _loc2_ + "\' t=\'" + _loc6_ + "\' pr=\'" + _loc4_ + "\' pe=\'" + _loc5_ + "\'><![CDATA[" + _loc3_ + "]]></var>";
  225.          }
  226.          return "";
  227.       }
  228.       
  229.       private function handleSocketDisconnection(param1:Event) : void
  230.       {
  231.          var _loc2_:SFSEvent = null;
  232.          initialize();
  233.          _loc2_ = new SFSEvent(SFSEvent.onConnectionLost,{});
  234.          dispatchEvent(_loc2_);
  235.       }
  236.       
  237.       private function xmlReceived(param1:String) : void
  238.       {
  239.          var _loc2_:XML = null;
  240.          var _loc3_:String = null;
  241.          var _loc4_:String = null;
  242.          var _loc5_:int = 0;
  243.          var _loc6_:IMessageHandler = null;
  244.          _loc2_ = new XML(param1);
  245.          _loc3_ = _loc2_.@t;
  246.          _loc4_ = _loc2_.body.@action;
  247.          _loc5_ = int(_loc2_.body.@r);
  248.          if((_loc6_ = messageHandlers[_loc3_]) != null)
  249.          {
  250.             _loc6_.handleMessage(_loc2_,XTMSG_TYPE_XML);
  251.          }
  252.       }
  253.       
  254.       public function switchSpectator(param1:int = -1) : void
  255.       {
  256.          if(param1 == -1)
  257.          {
  258.             param1 = activeRoomId;
  259.          }
  260.          send({"t":"sys"},"swSpec",param1,"");
  261.       }
  262.       
  263.       public function roundTripBench() : void
  264.       {
  265.          this.benchStartTime = getTimer();
  266.          send({"t":"sys"},"roundTrip",activeRoomId,"");
  267.       }
  268.       
  269.       public function joinRoom(param1:*, param2:String = "", param3:Boolean = false, param4:Boolean = false, param5:int = -1) : void
  270.       {
  271.          var _loc6_:int = 0;
  272.          var _loc7_:int = 0;
  273.          var _loc8_:Room = null;
  274.          var _loc9_:Object = null;
  275.          var _loc10_:String = null;
  276.          var _loc11_:int = 0;
  277.          var _loc12_:* = null;
  278.          _loc6_ = -1;
  279.          _loc7_ = param3 ? 1 : 0;
  280.          if(!this.changingRoom)
  281.          {
  282.             if(typeof param1 == "number")
  283.             {
  284.                _loc6_ = int(param1);
  285.             }
  286.             else if(typeof param1 == "string")
  287.             {
  288.                for each(_loc8_ in roomList)
  289.                {
  290.                   if(_loc8_.getName() == param1)
  291.                   {
  292.                      _loc6_ = _loc8_.getId();
  293.                      break;
  294.                   }
  295.                }
  296.             }
  297.             if(_loc6_ != -1)
  298.             {
  299.                _loc9_ = {"t":"sys"};
  300.                _loc10_ = param4 ? "0" : "1";
  301.                _loc11_ = param5 > -1 ? param5 : activeRoomId;
  302.                if(activeRoomId == -1)
  303.                {
  304.                   _loc10_ = "0";
  305.                   _loc11_ = -1;
  306.                }
  307.                _loc12_ = "<room id=\'" + _loc6_ + "\' pwd=\'" + param2 + "\' spec=\'" + _loc7_ + "\' leave=\'" + _loc10_ + "\' old=\'" + _loc11_ + "\' />";
  308.                send(_loc9_,"joinRoom",activeRoomId,_loc12_);
  309.                changingRoom = true;
  310.             }
  311.             else
  312.             {
  313.                trace("SmartFoxError: requested room to join does not exist!");
  314.             }
  315.          }
  316.       }
  317.       
  318.       public function getActiveRoom() : Room
  319.       {
  320.          return roomList[activeRoomId];
  321.       }
  322.       
  323.       private function makeXmlHeader(param1:Object) : String
  324.       {
  325.          var _loc2_:String = null;
  326.          var _loc3_:String = null;
  327.          _loc2_ = "<msg";
  328.          for(_loc3_ in param1)
  329.          {
  330.             _loc2_ += " " + _loc3_ + "=\'" + param1[_loc3_] + "\'";
  331.          }
  332.          return _loc2_ + ">";
  333.       }
  334.       
  335.       private function strReceived(param1:String) : void
  336.       {
  337.          var _loc2_:Array = null;
  338.          var _loc3_:String = null;
  339.          var _loc4_:IMessageHandler = null;
  340.          _loc2_ = param1.substr(1,param1.length - 2).split(MSG_STR);
  341.          _loc3_ = String(_loc2_[0]);
  342.          if((_loc4_ = messageHandlers[_loc3_]) != null)
  343.          {
  344.             _loc4_.handleMessage(_loc2_.splice(1,_loc2_.length - 1),XTMSG_TYPE_STR);
  345.          }
  346.       }
  347.       
  348.       public function getRoomByName(param1:String) : Room
  349.       {
  350.          var _loc2_:Room = null;
  351.          var _loc3_:Room = null;
  352.          _loc2_ = null;
  353.          for each(_loc3_ in roomList)
  354.          {
  355.             if(_loc3_.getName() == param1)
  356.             {
  357.                _loc2_ = _loc3_;
  358.                break;
  359.             }
  360.          }
  361.          return _loc2_;
  362.       }
  363.       
  364.       public function loadBuddyList() : void
  365.       {
  366.          send({"t":"sys"},"loadB",-1,"");
  367.       }
  368.       
  369.       public function leaveRoom(param1:int) : void
  370.       {
  371.          var _loc2_:Object = null;
  372.          var _loc3_:* = null;
  373.          _loc2_ = {"t":"sys"};
  374.          _loc3_ = "<rm id=\'" + param1 + "\' />";
  375.          send(_loc2_,"leaveRoom",param1,_loc3_);
  376.       }
  377.       
  378.       private function addMessageHandler(param1:String, param2:IMessageHandler) : void
  379.       {
  380.          if(this.messageHandlers[param1] == null)
  381.          {
  382.             this.messageHandlers[param1] = param2;
  383.          }
  384.          else
  385.          {
  386.             trace("Warning, message handler called: " + param1 + " already exist!");
  387.          }
  388.       }
  389.       
  390.       public function getAllRooms() : Array
  391.       {
  392.          return roomList;
  393.       }
  394.       
  395.       public function setBuddyVariables(param1:Array) : void
  396.       {
  397.          var _loc2_:Object = null;
  398.          var _loc3_:* = null;
  399.          var _loc4_:String = null;
  400.          var _loc5_:String = null;
  401.          _loc2_ = {"t":"sys"};
  402.          _loc3_ = "<vars>";
  403.          for(_loc4_ in param1)
  404.          {
  405.             _loc5_ = String(param1[_loc4_]);
  406.             if(buddyVars[_loc4_] != _loc5_)
  407.             {
  408.                buddyVars[_loc4_] = _loc5_;
  409.                _loc3_ += "<var n=\'" + _loc4_ + "\'><![CDATA[" + _loc5_ + "]]></var>";
  410.             }
  411.          }
  412.          _loc3_ += "</vars>";
  413.          this.send(_loc2_,"setBvars",-1,_loc3_);
  414.       }
  415.       
  416.       public function getRoom(param1:int) : Room
  417.       {
  418.          return roomList[param1];
  419.       }
  420.       
  421.       private function handleSecurityError(param1:Event) : void
  422.       {
  423.          trace("SECURITY ERROR!!!");
  424.       }
  425.       
  426.       private function handleIOError(param1:Event) : void
  427.       {
  428.          var _loc2_:SFSEvent = null;
  429.          var _loc3_:Object = null;
  430.          if(!connected)
  431.          {
  432.             _loc3_ = {};
  433.             _loc3_.success = false;
  434.             _loc3_.error = "I/O Error";
  435.             _loc2_ = new SFSEvent(SFSEvent.onConnection,_loc3_);
  436.             dispatchEvent(_loc2_);
  437.          }
  438.          else
  439.          {
  440.             trace("I/O Error during connected session");
  441.          }
  442.       }
  443.       
  444.       private function setupMessageHandlers() : void
  445.       {
  446.          sysHandler = new SysHandler(this);
  447.          extHandler = new ExtHandler(this);
  448.          addMessageHandler("sys",sysHandler);
  449.          addMessageHandler("xt",extHandler);
  450.       }
  451.       
  452.       public function login(param1:String, param2:String, param3:String) : void
  453.       {
  454.          var _loc4_:Object = null;
  455.          var _loc5_:* = null;
  456.          _loc4_ = {"t":"sys"};
  457.          _loc5_ = "<login z=\'" + param1 + "\'><nick><![CDATA[" + param2 + "]]></nick><pword><![CDATA[" + param3 + "]]></pword></login>";
  458.          send(_loc4_,"login",0,_loc5_);
  459.       }
  460.       
  461.       public function autoJoin() : void
  462.       {
  463.          var _loc1_:Object = null;
  464.          _loc1_ = {"t":"sys"};
  465.          this.send(_loc1_,"autoJoin",!!this.activeRoomId ? this.activeRoomId : -1,"");
  466.       }
  467.       
  468.       private function send(param1:Object, param2:String, param3:Number, param4:String) : void
  469.       {
  470.          var _loc5_:String = null;
  471.          _loc5_ = (_loc5_ = makeXmlHeader(param1)) + ("<body action=\'" + param2 + "\' r=\'" + param3 + "\'>" + param4 + "</body>" + closeHeader());
  472.          if(this.debug)
  473.          {
  474.             trace("[Sending]: " + _loc5_ + "\n");
  475.          }
  476.          writeToSocket(_loc5_);
  477.       }
  478.       
  479.       public function getRoomList() : void
  480.       {
  481.          var _loc1_:Object = null;
  482.          _loc1_ = {"t":"sys"};
  483.          send(_loc1_,"getRmList",activeRoomId,"");
  484.       }
  485.       
  486.       private function initialize() : void
  487.       {
  488.          this.changingRoom = false;
  489.          this.amIModerator = false;
  490.          this.playerId = -1;
  491.          this.connected = false;
  492.          this.roomList = [];
  493.          this.buddyList = [];
  494.          this.buddyVars = [];
  495.       }
  496.       
  497.       public function setRoomVariables(param1:Array, param2:int = -1, param3:Boolean = true) : void
  498.       {
  499.          var _loc4_:Object = null;
  500.          var _loc5_:* = null;
  501.          var _loc6_:Object = null;
  502.          if(param2 == -1)
  503.          {
  504.             param2 = activeRoomId;
  505.          }
  506.          _loc4_ = {"t":"sys"};
  507.          if(param3)
  508.          {
  509.             _loc5_ = "<vars>";
  510.          }
  511.          else
  512.          {
  513.             _loc5_ = "<vars so=\'0\'>";
  514.          }
  515.          for each(_loc6_ in param1)
  516.          {
  517.             _loc5_ += getXmlRoomVariable(_loc6_);
  518.          }
  519.          _loc5_ += "</vars>";
  520.          send(_loc4_,"setRvars",param2,_loc5_);
  521.       }
  522.       
  523.       public function disconnect() : void
  524.       {
  525.          socketConnection.close();
  526.          connected = false;
  527.          sysHandler.dispatchDisconnection();
  528.       }
  529.       
  530.       public function sendJson(param1:String) : void
  531.       {
  532.          if(this.debug)
  533.          {
  534.             trace("[Sending - JSON]: " + param1 + "\n");
  535.          }
  536.          writeToSocket(param1);
  537.       }
  538.       
  539.       private function closeHeader() : String
  540.       {
  541.          return "</msg>";
  542.       }
  543.       
  544.       public function getVersion() : String
  545.       {
  546.          return this.majVersion + "." + this.minVersion + "." + this.subVersion;
  547.       }
  548.       
  549.       public function setUserVariables(param1:Object, param2:int = -1) : void
  550.       {
  551.          var _loc3_:Object = null;
  552.          var _loc4_:Room = null;
  553.          var _loc5_:User = null;
  554.          var _loc6_:String = null;
  555.          if(param2 == -1)
  556.          {
  557.             param2 = activeRoomId;
  558.          }
  559.          _loc3_ = {"t":"sys"};
  560.          _loc5_ = (_loc4_ = getActiveRoom()).getUser(myUserId);
  561.          _loc6_ = getXmlUserVariable(param1);
  562.          send(_loc3_,"setUvars",param2,_loc6_);
  563.       }
  564.       
  565.       public function addBuddy(param1:String) : void
  566.       {
  567.          var _loc2_:* = null;
  568.          if(param1 != myUserName && !checkBuddyDuplicates(param1))
  569.          {
  570.             _loc2_ = "<n>" + param1 + "</n>";
  571.             send({"t":"sys"},"addB",-1,_loc2_);
  572.          }
  573.       }
  574.       
  575.       public function sendPrivateMessage(param1:String, param2:int, param3:int = -1) : void
  576.       {
  577.          var _loc4_:Object = null;
  578.          var _loc5_:* = null;
  579.          if(param3 == -1)
  580.          {
  581.             param3 = activeRoomId;
  582.          }
  583.          _loc4_ = {"t":"sys"};
  584.          _loc5_ = "<txt rcp=\'" + param2 + "\'><![CDATA[" + Entities.encodeEntities(param1) + "]]></txt>";
  585.          send(_loc4_,"prvMsg",param3,_loc5_);
  586.       }
  587.       
  588.       public function sendPublicMessage(param1:String, param2:int = -1) : void
  589.       {
  590.          var _loc3_:Object = null;
  591.          var _loc4_:* = null;
  592.          if(param2 == -1)
  593.          {
  594.             param2 = activeRoomId;
  595.          }
  596.          _loc3_ = {"t":"sys"};
  597.          _loc4_ = "<txt><![CDATA[" + Entities.encodeEntities(param1) + "]]></txt>";
  598.          send(_loc3_,"pubMsg",param2,_loc4_);
  599.       }
  600.       
  601.       public function clearBuddyList() : void
  602.       {
  603.          var _loc1_:Object = null;
  604.          var _loc2_:SFSEvent = null;
  605.          buddyList = [];
  606.          send({"t":"sys"},"clearB",-1,"");
  607.          _loc1_ = {};
  608.          _loc1_.list = buddyList;
  609.          _loc2_ = new SFSEvent(SFSEvent.onBuddyList,_loc1_);
  610.          dispatchEvent(_loc2_);
  611.       }
  612.       
  613.       public function sendString(param1:String) : void
  614.       {
  615.          if(this.debug)
  616.          {
  617.             trace("[Sending - STR]: " + param1 + "\n");
  618.          }
  619.          writeToSocket(param1);
  620.       }
  621.       
  622.       public function removeBuddy(param1:String) : void
  623.       {
  624.          var _loc2_:Boolean = false;
  625.          var _loc3_:Object = null;
  626.          var _loc4_:String = null;
  627.          var _loc5_:Object = null;
  628.          var _loc6_:* = null;
  629.          var _loc7_:Object = null;
  630.          var _loc8_:SFSEvent = null;
  631.          _loc2_ = false;
  632.          for(_loc4_ in buddyList)
  633.          {
  634.             _loc3_ = buddyList[_loc4_];
  635.             if(_loc3_.name == param1)
  636.             {
  637.                delete buddyList[_loc4_];
  638.                _loc2_ = true;
  639.                break;
  640.             }
  641.          }
  642.          if(_loc2_)
  643.          {
  644.             _loc5_ = {"t":"sys"};
  645.             _loc6_ = "<n>" + param1 + "</n>";
  646.             send(_loc5_,"remB",-1,_loc6_);
  647.             (_loc7_ = {}).list = buddyList;
  648.             _loc8_ = new SFSEvent(SFSEvent.onBuddyList,_loc7_);
  649.             dispatchEvent(_loc8_);
  650.          }
  651.       }
  652.       
  653.       private function handleMessage(param1:String) : void
  654.       {
  655.          var _loc2_:String = null;
  656.          if(this.debug)
  657.          {
  658.             trace("[ RECEIVED ]: " + param1 + ", (len: " + param1.length + ")");
  659.          }
  660.          _loc2_ = param1.charAt(0);
  661.          if(_loc2_ == MSG_XML)
  662.          {
  663.             if(param1.substr(0,4) == "<msg" && param1.substr(-6) != "</msg>")
  664.             {
  665.                param1 += "</body></msg>";
  666.             }
  667.             xmlReceived(param1);
  668.          }
  669.          else if(_loc2_ == MSG_STR)
  670.          {
  671.             strReceived(param1);
  672.          }
  673.          else if(_loc2_ == MSG_JSON)
  674.          {
  675.             jsonReceived(param1);
  676.          }
  677.       }
  678.       
  679.       public function sendXtMessage(param1:String, param2:String, param3:*, param4:String = "xml", param5:int = -1) : void
  680.       {
  681.          var _loc6_:Object = null;
  682.          var _loc7_:Object = null;
  683.          var _loc8_:* = null;
  684.          var _loc9_:* = null;
  685.          var _loc10_:Number = NaN;
  686.          var _loc11_:Object = null;
  687.          var _loc12_:Object = null;
  688.          var _loc13_:String = null;
  689.          if(param5 == -1)
  690.          {
  691.             param5 = activeRoomId;
  692.          }
  693.          if(param4 == XTMSG_TYPE_XML)
  694.          {
  695.             _loc6_ = {"t":"xt"};
  696.             _loc7_ = {
  697.                "name":param1,
  698.                "cmd":param2,
  699.                "param":param3
  700.             };
  701.             _loc8_ = "<![CDATA[" + ObjectSerializer.getInstance().serialize(_loc7_) + "]]>";
  702.             send(_loc6_,"xtReq",param5,_loc8_);
  703.          }
  704.          else if(param4 == XTMSG_TYPE_STR)
  705.          {
  706.             _loc9_ = "%xt%" + param1 + "%" + param2 + "%" + param5 + "%";
  707.             _loc10_ = 0;
  708.             while(_loc10_ < param3.length)
  709.             {
  710.                _loc9_ += param3[_loc10_].toString() + "%";
  711.                _loc10_++;
  712.             }
  713.             sendString(_loc9_);
  714.          }
  715.          else if(param4 == XTMSG_TYPE_JSON)
  716.          {
  717.             (_loc11_ = {}).x = param1;
  718.             _loc11_.c = param2;
  719.             _loc11_.r = param5;
  720.             _loc11_.p = param3;
  721.             (_loc12_ = {}).t = "xt";
  722.             _loc12_.b = _loc11_;
  723.             _loc13_ = it.gotoandplay.smartfoxserver.json.JSON.encode(_loc12_);
  724.             sendJson(_loc13_);
  725.          }
  726.       }
  727.       
  728.       private function writeToSocket(param1:String) : void
  729.       {
  730.          var _loc2_:ByteArray = null;
  731.          _loc2_ = new ByteArray();
  732.          _loc2_.writeMultiByte(param1,"utf-8");
  733.          _loc2_.writeByte(0);
  734.          socketConnection.writeBytes(_loc2_);
  735.          socketConnection.flush();
  736.       }
  737.       
  738.       public function sendObjectToGroup(param1:Object, param2:Array, param3:int) : void
  739.       {
  740.          var _loc4_:String = null;
  741.          var _loc5_:String = null;
  742.          var _loc6_:Object = null;
  743.          var _loc7_:* = null;
  744.          if(param3 == -1)
  745.          {
  746.             param3 = activeRoomId;
  747.          }
  748.          _loc4_ = "";
  749.          for(_loc5_ in param2)
  750.          {
  751.             if(!isNaN(param2[_loc5_]))
  752.             {
  753.                _loc4_ += param2[_loc5_] + ",";
  754.             }
  755.          }
  756.          _loc4_ = _loc4_.substr(0,_loc4_.length - 1);
  757.          param1._$$_ = _loc4_;
  758.          _loc6_ = {"t":"sys"};
  759.          _loc7_ = "<![CDATA[" + ObjectSerializer.getInstance().serialize(param1) + "]]>";
  760.          send(_loc6_,"asObjG",param3,_loc7_);
  761.       }
  762.       
  763.       public function getRandomKey() : void
  764.       {
  765.          send({"t":"sys"},"rndK",-1,"");
  766.       }
  767.       
  768.       public function sendObject(param1:Object, param2:int = -1) : void
  769.       {
  770.          var _loc3_:* = null;
  771.          var _loc4_:Object = null;
  772.          if(param2 == -1)
  773.          {
  774.             param2 = activeRoomId;
  775.          }
  776.          _loc3_ = "<![CDATA[" + ObjectSerializer.getInstance().serialize(param1) + "]]>";
  777.          _loc4_ = {"t":"sys"};
  778.          send(_loc4_,"asObj",param2,_loc3_);
  779.       }
  780.       
  781.       private function jsonReceived(param1:String) : void
  782.       {
  783.          var _loc2_:Object = null;
  784.          var _loc3_:String = null;
  785.          var _loc4_:IMessageHandler = null;
  786.          _loc2_ = it.gotoandplay.smartfoxserver.json.JSON.decode(param1);
  787.          _loc3_ = String(_loc2_["t"]);
  788.          if((_loc4_ = messageHandlers[_loc3_]) != null)
  789.          {
  790.             _loc4_.handleMessage(_loc2_["b"],XTMSG_TYPE_JSON);
  791.          }
  792.       }
  793.       
  794.       public function connect(param1:String, param2:int) : void
  795.       {
  796.          if(!connected)
  797.          {
  798.             initialize();
  799.             socketConnection.connect(param1,param2);
  800.          }
  801.          else
  802.          {
  803.             trace("*** ALREADY CONNECTED ***");
  804.          }
  805.       }
  806.       
  807.       public function sendModeratorMessage(param1:String, param2:int, param3:int = -1) : void
  808.       {
  809.          var _loc4_:Object = null;
  810.          var _loc5_:* = null;
  811.          _loc4_ = {"t":"sys"};
  812.          _loc5_ = "<txt t=\'" + param2 + "\' id=\'" + param3 + "\'><![CDATA[" + Entities.encodeEntities(param1) + "]]></txt>";
  813.          send(_loc4_,"modMsg",activeRoomId,_loc5_);
  814.       }
  815.       
  816.       public function getBenchStartTime() : int
  817.       {
  818.          return this.benchStartTime;
  819.       }
  820.       
  821.       public function createRoom(param1:Object, param2:int = -1) : void
  822.       {
  823.          var _loc3_:Object = null;
  824.          var _loc4_:String = null;
  825.          var _loc5_:String = null;
  826.          var _loc6_:String = null;
  827.          var _loc7_:String = null;
  828.          var _loc8_:* = null;
  829.          var _loc9_:String = null;
  830.          if(param2 == -1)
  831.          {
  832.             param2 = activeRoomId;
  833.          }
  834.          _loc3_ = {"t":"sys"};
  835.          _loc4_ = !!param1.isGame ? "1" : "0";
  836.          _loc5_ = "1";
  837.          _loc6_ = param1.maxUsers == null ? "0" : String(param1.maxUsers);
  838.          _loc7_ = param1.maxSpectators == null ? "0" : String(param1.maxSpectators);
  839.          if(Boolean(param1.isGame) && param1.exitCurrent != null)
  840.          {
  841.             _loc5_ = !!param1.exitCurrent ? "1" : "0";
  842.          }
  843.          _loc8_ = (_loc8_ = (_loc8_ = (_loc8_ = "<room tmp=\'1\' gam=\'" + _loc4_ + "\' spec=\'" + _loc7_ + "\' exit=\'" + _loc5_ + "\'>") + ("<name><![CDATA[" + (param1.name == null ? "" : param1.name) + "]]></name>")) + ("<pwd><![CDATA[" + (param1.password == null ? "" : param1.password) + "]]></pwd>")) + ("<max>" + _loc6_ + "</max>");
  844.          if(param1.uCount != null)
  845.          {
  846.             _loc8_ += "<uCnt>" + (!!param1.uCount ? "1" : "0") + "</uCnt>";
  847.          }
  848.          if(param1.extension != null)
  849.          {
  850.             _loc8_ = (_loc8_ += "<xt n=\'" + param1.extension.name) + ("\' s=\'" + param1.extension.script + "\' />");
  851.          }
  852.          if(param1.vars == null)
  853.          {
  854.             _loc8_ += "<vars></vars>";
  855.          }
  856.          else
  857.          {
  858.             _loc8_ += "<vars>";
  859.             for(_loc9_ in param1.vars)
  860.             {
  861.                _loc8_ += getXmlRoomVariable(param1.vars[_loc9_]);
  862.             }
  863.             _loc8_ += "</vars>";
  864.          }
  865.          _loc8_ += "</room>";
  866.          send(_loc3_,"createRoom",param2,_loc8_);
  867.       }
  868.       
  869.       private function handleSocketConnection(param1:Event) : void
  870.       {
  871.          var _loc2_:Object = null;
  872.          var _loc3_:* = null;
  873.          _loc2_ = {"t":"sys"};
  874.          _loc3_ = "<ver v=\'" + this.majVersion.toString() + this.minVersion.toString() + this.subVersion.toString() + "\' />";
  875.          send(_loc2_,"verChk",0,_loc3_);
  876.       }
  877.       
  878.       public function set isConnected(param1:Boolean) : void
  879.       {
  880.          this.connected = param1;
  881.       }
  882.       
  883.       public function get isConnected() : Boolean
  884.       {
  885.          return this.connected;
  886.       }
  887.    }
  888. }
  889.