home *** CD-ROM | disk | FTP | other *** search
/ Champak 130 / Vol 130.iso / games / target_s.swf / scripts / assets / screens / screen_learn.as next >
Encoding:
Text File  |  2008-11-13  |  9.3 KB  |  356 lines
  1. package assets.screens
  2. {
  3.    import flash.display.*;
  4.    import flash.events.*;
  5.    
  6.    [Embed(source="/_assets/assets.swf", symbol="assets.screens.screen_learn")]
  7.    public class screen_learn extends MovieClip
  8.    {
  9.        
  10.       
  11.       public var key3_mc:MovieClip;
  12.       
  13.       private var keySP:Boolean = false;
  14.       
  15.       private var keySH:Boolean = false;
  16.       
  17.       private var keyLT:Boolean = false;
  18.       
  19.       private var keyDN:Boolean = false;
  20.       
  21.       public var continueBtn:SimpleButton;
  22.       
  23.       public var key1_mc:MovieClip;
  24.       
  25.       private var keys:Array;
  26.       
  27.       private var scope:Object;
  28.       
  29.       public var keyDN_mc:MovieClip;
  30.       
  31.       public var menuBtn:SimpleButton;
  32.       
  33.       public var imagebox:MovieClip;
  34.       
  35.       public var key4_mc:MovieClip;
  36.       
  37.       private var keyUP:Boolean = false;
  38.       
  39.       public var key2_mc:MovieClip;
  40.       
  41.       private var key2:Boolean = false;
  42.       
  43.       public var keyLT_mc:MovieClip;
  44.       
  45.       public var keySP_mc:MovieClip;
  46.       
  47.       public var keyRT_mc:MovieClip;
  48.       
  49.       private var key5:Boolean = false;
  50.       
  51.       private var key1:Boolean = false;
  52.       
  53.       public var keyUP_mc:MovieClip;
  54.       
  55.       private var key3:Boolean = false;
  56.       
  57.       private var key4:Boolean = false;
  58.       
  59.       public var key5_mc:MovieClip;
  60.       
  61.       private var keyRT:Boolean = false;
  62.       
  63.       public function screen_learn(param1:*)
  64.       {
  65.          var _loc2_:* = undefined;
  66.          var _loc3_:* = undefined;
  67.          key1 = false;
  68.          key2 = false;
  69.          key3 = false;
  70.          key4 = false;
  71.          key5 = false;
  72.          keyUP = false;
  73.          keyLT = false;
  74.          keyDN = false;
  75.          keyRT = false;
  76.          keySP = false;
  77.          keySH = false;
  78.          keys = new Array();
  79.          super();
  80.          addFrameScript(0,frame1);
  81.          scope = param1;
  82.          scope.stage.focus = this;
  83.          addEventListener(Event.REMOVED_FROM_STAGE,onRemove);
  84.          addEventListener(Event.ENTER_FRAME,process);
  85.          addEventListener(KeyboardEvent.KEY_DOWN,keyCapture);
  86.          addEventListener(KeyboardEvent.KEY_UP,keyRelease);
  87.          menuBtn.addEventListener(MouseEvent.CLICK,onMenu);
  88.          continueBtn.addEventListener(MouseEvent.CLICK,nextPage);
  89.          keys = [keySP_mc,keyUP_mc,keyDN_mc,keyLT_mc,keyRT_mc,key1_mc,key2_mc,key3_mc,key4_mc,key5_mc];
  90.          _loc2_ = 0;
  91.          while(_loc2_ < keys.length)
  92.          {
  93.             keys[_loc2_].visible = false;
  94.             _loc2_++;
  95.          }
  96.          _loc3_ = 1;
  97.          while(_loc3_ < 5)
  98.          {
  99.             keys[_loc3_].visible = true;
  100.             _loc3_++;
  101.          }
  102.       }
  103.       
  104.       private function nextPage(param1:MouseEvent) : *
  105.       {
  106.          var _loc2_:* = undefined;
  107.          var _loc3_:* = undefined;
  108.          var _loc4_:* = undefined;
  109.          if(currentFrame < totalFrames)
  110.          {
  111.             nextFrame();
  112.          }
  113.          else
  114.          {
  115.             gotoAndStop(1);
  116.          }
  117.          _loc2_ = 0;
  118.          while(_loc2_ < keys.length)
  119.          {
  120.             keys[_loc2_].visible = false;
  121.             _loc2_++;
  122.          }
  123.          switch(currentFrame)
  124.          {
  125.             case 1:
  126.                _loc3_ = 1;
  127.                while(_loc3_ < 5)
  128.                {
  129.                   keys[_loc3_].visible = true;
  130.                   _loc3_++;
  131.                }
  132.                break;
  133.             case 2:
  134.                keys[0].visible = true;
  135.                break;
  136.             case 3:
  137.                _loc4_ = 5;
  138.                while(_loc4_ < 10)
  139.                {
  140.                   keys[_loc4_].visible = true;
  141.                   _loc4_++;
  142.                }
  143.          }
  144.       }
  145.       
  146.       private function onRemove(param1:Event) : *
  147.       {
  148.          removeEventListener(Event.REMOVED_FROM_STAGE,onRemove);
  149.          removeEventListener(Event.ENTER_FRAME,process);
  150.          removeEventListener(KeyboardEvent.KEY_DOWN,keyCapture);
  151.          removeEventListener(KeyboardEvent.KEY_UP,keyRelease);
  152.          menuBtn.removeEventListener(MouseEvent.CLICK,onMenu);
  153.          continueBtn.removeEventListener(MouseEvent.CLICK,nextPage);
  154.       }
  155.       
  156.       internal function frame1() : *
  157.       {
  158.          stop();
  159.       }
  160.       
  161.       private function process(param1:Event) : *
  162.       {
  163.          switch(currentFrame)
  164.          {
  165.             case 1:
  166.                if(keyUP)
  167.                {
  168.                   keyUP_mc.gotoAndStop("on");
  169.                   imagebox.gotoAndStop(2);
  170.                }
  171.                else
  172.                {
  173.                   keyUP_mc.gotoAndStop("off");
  174.                }
  175.                if(keyDN)
  176.                {
  177.                   keyDN_mc.gotoAndStop("on");
  178.                   imagebox.gotoAndStop(3);
  179.                }
  180.                else
  181.                {
  182.                   keyDN_mc.gotoAndStop("off");
  183.                }
  184.                if(keyLT)
  185.                {
  186.                   keyLT_mc.gotoAndStop("on");
  187.                   imagebox.gotoAndStop(5);
  188.                }
  189.                else
  190.                {
  191.                   keyLT_mc.gotoAndStop("off");
  192.                }
  193.                if(keyRT)
  194.                {
  195.                   keyRT_mc.gotoAndStop("on");
  196.                   imagebox.gotoAndStop(4);
  197.                }
  198.                else
  199.                {
  200.                   keyRT_mc.gotoAndStop("off");
  201.                }
  202.                if(!keyUP && !keyDN && !keyLT && !keyRT)
  203.                {
  204.                   imagebox.gotoAndStop(1);
  205.                }
  206.                break;
  207.             case 2:
  208.                if(keySP)
  209.                {
  210.                   keySP_mc.gotoAndStop("on");
  211.                   imagebox.gotoAndStop(7);
  212.                }
  213.                else
  214.                {
  215.                   keySP_mc.gotoAndStop("off");
  216.                   imagebox.gotoAndStop(6);
  217.                }
  218.                break;
  219.             case 3:
  220.                if(key1)
  221.                {
  222.                   key1_mc.gotoAndStop("on");
  223.                   imagebox.gotoAndStop(9);
  224.                }
  225.                else
  226.                {
  227.                   key1_mc.gotoAndStop("off");
  228.                }
  229.                if(key2)
  230.                {
  231.                   key2_mc.gotoAndStop("on");
  232.                   imagebox.gotoAndStop(10);
  233.                }
  234.                else
  235.                {
  236.                   key2_mc.gotoAndStop("off");
  237.                }
  238.                if(key3)
  239.                {
  240.                   key3_mc.gotoAndStop("on");
  241.                   imagebox.gotoAndStop(11);
  242.                }
  243.                else
  244.                {
  245.                   key3_mc.gotoAndStop("off");
  246.                }
  247.                if(key4)
  248.                {
  249.                   key4_mc.gotoAndStop("on");
  250.                   imagebox.gotoAndStop(12);
  251.                }
  252.                else
  253.                {
  254.                   key4_mc.gotoAndStop("off");
  255.                }
  256.                if(key5)
  257.                {
  258.                   key5_mc.gotoAndStop("on");
  259.                   imagebox.gotoAndStop(13);
  260.                }
  261.                else
  262.                {
  263.                   key5_mc.gotoAndStop("off");
  264.                }
  265.                if(!key1 && !key2 && !key3 && !key4 && !key5)
  266.                {
  267.                   imagebox.gotoAndStop(8);
  268.                }
  269.          }
  270.       }
  271.       
  272.       private function keyRelease(param1:KeyboardEvent) : void
  273.       {
  274.          switch(param1.keyCode)
  275.          {
  276.             case 65:
  277.                key1 = false;
  278.                break;
  279.             case 83:
  280.                key2 = false;
  281.                break;
  282.             case 68:
  283.                key3 = false;
  284.                break;
  285.             case 70:
  286.                key4 = false;
  287.                break;
  288.             case 71:
  289.                key5 = false;
  290.                break;
  291.             case 38:
  292.                keyUP = false;
  293.                break;
  294.             case 37:
  295.                keyLT = false;
  296.                break;
  297.             case 39:
  298.                keyRT = false;
  299.                break;
  300.             case 40:
  301.                keyDN = false;
  302.                break;
  303.             case 32:
  304.                keySP = false;
  305.                break;
  306.             case 16:
  307.                keySH = false;
  308.          }
  309.       }
  310.       
  311.       private function onMenu(param1:MouseEvent) : *
  312.       {
  313.          scope.setScreen(0);
  314.       }
  315.       
  316.       private function keyCapture(param1:KeyboardEvent) : void
  317.       {
  318.          switch(param1.keyCode)
  319.          {
  320.             case 65:
  321.                key1 = true;
  322.                break;
  323.             case 83:
  324.                key2 = true;
  325.                break;
  326.             case 68:
  327.                key3 = true;
  328.                break;
  329.             case 70:
  330.                key4 = true;
  331.                break;
  332.             case 71:
  333.                key5 = true;
  334.                break;
  335.             case 38:
  336.                keyUP = true;
  337.                break;
  338.             case 37:
  339.                keyLT = true;
  340.                break;
  341.             case 39:
  342.                keyRT = true;
  343.                break;
  344.             case 40:
  345.                keyDN = true;
  346.                break;
  347.             case 32:
  348.                keySP = true;
  349.                break;
  350.             case 16:
  351.                keySH = true;
  352.          }
  353.       }
  354.    }
  355. }
  356.