//It should extends GameRoot. The GameRoot extends a starling.display.Sprite.
     public class TictactoeImpl extends GameRoot 
     {
     
         //constructor
         public function TictactoeImpl(){ 
                 
             //Create the graphics for game (for example)
             _theme = new OriginalTheme(this);
             
             //call super class with default values. It creates the default header with the players and avatars 
             super();
     
         }
     
         //override function to receive players after the match making process
         override public function matchPrepare(players:Array, me:Number):void
         {
             
             //call the function in extended class
             super.matchPrepare(players, me);
             
             //Create the screen (for example)
             _playScreen  = new PlayScreen();    
     
             //add the screen to display list 
             addChild(_playScreen);
     
             //inform the phune gaming server that is ready to receive moves.
             ready(true);
         }
     
         //The match will start after receiving this event
         override public function matchStart(isMe:Boolean):void 
         {
             //call the function in extended class
             super.matchStart(isMe);
         
             //start the match in UI (for example)
             _playScreen.matchStart(isMe);
         }
     
         //received after sending a play to the server. the plays will be evaluated in the server.
         override public function confirmPlay(success:Boolean, playData:String, evaluationContent:String, nextPlayerId:Number):void 
         {
             //call the function in extended class
             super.confirmPlay(success, playData, evaluationContent, nextPlayerId);
         
             //If not succes (invalid move) 
             if (!success) {
                 //The UI should retract the move.
                 _playScreen.retractMove();
             }
         }
     
         //Received after an opponent play.
         override public function oponentPlay(playData:String, evaluationcontent:String, playerId:Number, nextPlayerId:Number):void 
         {
             //call the function in extended class
             super.oponentPlay(playData, evaluationcontent, playerId, nextPlayerId);
         
             //Convert the move to an object (in this example is in json format)
             var move:MoveVO = UtilService.jsonDecode(playData, MoveVO);
         
             //update UI
             _playScreen.opponentMove(move.posY + move.posX);
         }
     
         //received in the end of match.
         override public function endMatchResult(winContent:String, isTie:Boolean, playerWinner:Number):void 
         {
             //call the function in extended class
             super.endMatchResult(winContent, isTie, playerWinner);
         
             //If it´s not tie it should update the UI (in this example)
             if(!isTie){
                 _playScreen.endMatch(winContent);
             }
         }
     
         //example function that the UI will call the platform
         private function doPlay(index:int):void
         {
             //Create the move Object
             var move:MoveVO = new MoveVO();
             move.className = "Move";
             move.posX = index % 3;
             move.posY =  Math.floor(index / 3);
         
             //Stringify the object (convert a AS3 object to a json object format)
             var jsonObject:String = JSON.stringify(move);
         
             //Call the GameRootsend doPlay function to send the play to server the play
             doPlay(jsonObject, true);
         }
     }