开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > J2ME > 查看源码
MarioMainSprite.java
资源名称：J2ME&Game.rar　[点击查看]
上传用户：gyyuli
上传日期：2013-07-09
资源大小：3050k
文件大小：38k
源码类别：

J2ME

开发平台：

Java

MarioMainSprite.java：源码内容
  1. /**
  2.  * <p>Title: Mario</p>
  3.  * <p>Description:
  4.  * You cannot remove this copyright and notice.
  5.  * You cannot use this file any part without the express permission of the author.
  6.  * All Rights Reserved</p>
  7.  * <p>Copyright: lizhenpeng (c) 2004</p>
  8.  * <p>Company: LP&P</p>
  9.  * @author lizhenpeng
  10.  * @version 1.0.0
  11.  */
  13. package mario;
  15. import javax.microedition.lcdui.*;
  17. import lipeng.*;
  18. import java.io.*;
  20. public class MarioMainSprite
  21.   extends LPSprite
  22. {
  24.   public MarioMainSprite(MarioGameManage gm, LPMaps map)
  25.   {
  26.     this.gm = gm;
  27.     this.judgeMap = map;
  28.     mainSpriteState = SMALL_SPRITE;
  29.     this.gm = gm;
  30.   }
  32. //method
  33.   public void action()
  34.   {
  35.     bgdx=0;
  36.     bgdy=0;
  37.     switch(mainSpriteState)
  38.     {
  39.       case GROW_SPRITE:
  40.         if(++growCnt==10)
  41.         {
  42.           mainSpriteState=NORMAL_SPRITE;
  43.           growCnt=0;
  44.         }
  45.         else
  46.         {
  47.           if(growCnt%2==0)
  48.           {
  49.             y+=16;
  50.           }
  51.           else
  52.           {
  53.             y-=16;
  54.           }
  55.         }
  56.         break;
  57.       case BECOME_FIRE:
  58.         if(++becomeCnt==10)
  59.         {
  60.           mainSpriteState=FIRE_SPRITE;
  61.           becomeCnt=0;
  62.         }
  63.         break;
  64.       case DEAD_SPRITE:
  65.         if(deadCnt==0)
  66.         {
  67.           dy=-10;
  68.           frameCnt=10;
  69.         }
  70.         frameCnt=10;
  71.         ++dy;
  72.         y+=dy;
  73.         if(++deadCnt>=20)
  74.         {
  75.           deadCnt=0;
  76.           mainSpriteState=SMALL_SPRITE;
  77.           gm.gameState=MarioGameManage.GAMESTATE_REINIT;
  78.         }
  79.         break;
  80.       case BECOME_SMALL:
  81.         if(++becomeCnt==10)
  82.         {
  83.           mainSpriteState=SMALL_SPRITE;
  84.           becomeCnt=0;
  85.         }
  86.         break;
  87.       default:
  88.       {
  89.         dy+=2;
  90.         checkSpriteCollisionVertical();
  91.         checkTileCollisionVertical();
  92.         mainSpriteDamage();
  93.         y+=dy;
  95.         if(y+this.judgeMap.y<0)
  96.         {
  97.           y=0;
  98.           dy=0;
  99.         }
  100.         if(y<=MarioMIDlet.gameCanvas.height/4
  101.            ||
  102.            ((this.judgeMap.y!=
  103.              this.judgeMap.tileSize*this.judgeMap.h-
  104.              MarioMIDlet.gameCanvas.height)
  105.             &&y>=MarioMIDlet.gameCanvas.height/4)
  106.           )
  107.         {
  108.           this.bgdy=(MarioMIDlet.gameCanvas.height/4-y)>>2;
  110.           if(bgdy-this.judgeMap.y<
  111.              MarioMIDlet.gameCanvas.height-
  112.              this.judgeMap.tileSize*this.judgeMap.h)
  113.           {
  114.             bgdy=MarioMIDlet.gameCanvas.height-
  115.               this.judgeMap.tileSize*this.judgeMap.h+this.judgeMap.y;
  116.           }
  118.           if((this.judgeMap.y<=0)&&y<MarioMIDlet.gameCanvas.height/4)
  119.           {
  120.             this.judgeMap.y=0;
  121.             bgdy=0;
  122.           }
  123.         }
  124.         else
  125.         {
  126.           bgdy=0;
  127.         }
  129.         if((allAction&LPKeyMask.MASK_KEY_LEFT)!=0)
  130.         {
  131.           this.isLeft=true;
  132.           if(--dx<-MOVE_SPEED)
  133.           {
  134.             dx=-MOVE_SPEED;
  135.           }
  136.           if(checkTileCollisionHorizon())
  137.           {
  138.             dx=0;
  139.           }
  140.         }
  141.         else if((allAction&LPKeyMask.MASK_KEY_RIGHT)!=0)
  142.         {
  143.           this.isLeft=false;
  144.           if(++dx>MOVE_SPEED)
  145.           {
  146.             dx=MOVE_SPEED;
  147.           }
  148.           if(checkTileCollisionHorizon())
  149.           {
  150.             dx=0;
  151.           }
  152.         }
  153.         else
  154.         {
  155.           if(dx>0)
  156.           {
  157.             if(checkTileCollisionHorizon())
  158.             {
  159.               dx=0;
  160.             }
  161.             else
  162.             {
  163.               --dx;
  164.             }
  165.           }
  166.           else if(dx<0)
  167.           {
  168.             if(checkTileCollisionHorizon())
  169.             {
  170.               dx=0;
  171.             }
  172.             else
  173.             {
  174.               ++dx;
  175.             }
  176.           }
  177.         }
  178.         if(!checkSpriteCollisionHorizon())
  179.         {
  180.           x+=dx;
  181.           if(dx<0)
  182.           {
  183.             if(distance>=-gm.canvas.width)
  184.             {
  185.               distance+=dx;
  186.             }
  187.           }
  188.           if(distance<0)
  189.           {
  190.             if(dx>0)
  191.             {
  192.               distance+=dx;
  193.             }
  194.           }
  195.         }
  196.         else
  197.         {
  198.           dx=0;
  199.         }
  201.         if(this.x!=MarioMIDlet.gameCanvas.width/4)
  202.         {
  203.           this.bgdx=MarioMIDlet.gameCanvas.width/4-x;
  204.           if(distance<-(gm.canvas.width-MarioMIDlet.gameCanvas.width/4))
  205.           {
  206.             bgdx=0;
  207.           }
  208.         }
  209.         else
  210.         {
  211.           bgdx=0;
  212.         }
  213.         if(judgeMap.x-bgdx<0
  214.            ||
  215.            judgeMap.x-bgdx>
  216.            judgeMap.tileSize*judgeMap.w-MarioMIDlet.gameCanvas.width
  217.           )
  218.         {
  219.           bgdx=0;
  220.         }
  222.         if(mainSpriteState==FIRE_SPRITE)
  223.         {
  224.           if((allAction&LPKeyMask.MASK_KEY_OK_FLAG)!=0)
  225.           {
  226.             fire();
  227.           }
  228.           checkBulletDamage();
  229.         }
  231.         x+=this.bgdx;
  232.         judgeMap.x-=this.bgdx;
  234.         y+=this.bgdy;
  235.         judgeMap.y-=this.bgdy;
  237.         int tmpDy=this.bgdy;
  238.         if(judgeMap.y<0)
  239.         {
  240.           tmpDy=bgdy+judgeMap.y;
  241.           this.bgdy=-judgeMap.y;
  242.           judgeMap.y=0;
  243.           y+=this.bgdy;
  244.         }
  245.         bgdy=tmpDy;
  247.         if(x<0)
  248.         {
  249.           x=0;
  250.         }
  251.         if(this.x>=MarioMIDlet.gameCanvas.width-32)
  252.         {
  253.           this.x=MarioMIDlet.gameCanvas.width-32;
  254.         }
  255.         if(isLeft)
  256.         {
  257.           offset=5;
  258.         }
  259.         else
  260.         {
  261.           offset=0;
  262.         }
  264.         if(dy!=0)
  265.         {
  266.           frameCnt=offset+3;
  267.         }
  268.         else if(((allAction&LPKeyMask.MASK_KEY_LEFT)!=0)
  269.                 ||((allAction&LPKeyMask.MASK_KEY_RIGHT)!=0))
  270.         {
  271.           walk();
  272.         }
  273.         else if(dy==0&&(allAction&LPKeyMask.MASK_KEY_UP_FLAG)==0)
  274.         {
  275.           frameCnt=offset;
  276.         }
  277.         if(isProtected)
  278.         {
  279.           isHidden=!isHidden;
  280.           if(protectCnt++==protectInterval)
  281.           {
  282.             protectCnt=0;
  283.             isProtected=false;
  284.             isHidden=false;
  285.           }
  286.         }
  287.         else
  288.         {
  289.           checkEnemyCollision();
  290.         }
  291.         if((allAction&LPKeyMask.MASK_KEY_OK_FLAG)!=0)
  292.         {
  293.           if(mainSpriteState==FIRE_SPRITE)
  294.           {
  295.             frameCnt=offset+1;
  296.           }
  297.           allAction&=~LPKeyMask.MASK_KEY_OK_FLAG;
  298.         }
  300.         checkStaticSpriteCollision();
  302.         if(y>this.judgeMap.tileSize*this.judgeMap.h)
  303.         {
  304.           if(gm.menu.isVolOn)
  305.           {
  306.             gm.beatPlayer.replay();
  307.           }
  308.           gm.gameState=MarioGameManage.GAMESTATE_REINIT;
  309.         }
  310.       }
  311.       break;
  312.     }
  313.   }
  316.   private void spriteDeadAction()
  317.   {
  318.     if(gm.menu.isVolOn)
  319.     {
  320.       gm.beatPlayer.replay();
  321.     }
  322.     if(mainSpriteState==SMALL_SPRITE)
  323.     {
  324.       mainSpriteState=DEAD_SPRITE;
  325.       return;
  326.     }
  327.     else
  328.     {
  329.       mainSpriteState=BECOME_SMALL;
  330.       isProtected=true;
  331.       this.protectCnt=0;
  332.       this.protectInterval=20;
  333.       return;
  334.     }
  335.   }
  337.   private void checkEnemyCollision()
  338.   {
  339.     int i;
  340.     switch(mainSpriteState)
  341.     {
  342.       case SMALL_SPRITE:
  343.         rect1.x = x+2;
  344.         rect1.y = y;
  345.         rect1.dx = 12;
  346.         rect1.dy = 16;
  347.         break;
  348.       case NORMAL_SPRITE:
  349.       case FIRE_SPRITE:
  350.         rect1.x = x+6;
  351.         rect1.y = y+2;
  352.         rect1.dx = 20;
  353.         rect1.dy = 30;
  354.         break;
  355.     }
  356.     rect2.dx = 14;
  357.     rect2.dy = 14;
  358.     for(i=gm.enemy.length-1;i>=0;--i)
  359.     {
  360.       if(!gm.enemy[i].isHidden)
  361.       {
  362.         if(gm.enemy[i].isCheck)
  363.         {
  364.           rect2.x = gm.enemy[i].x;
  365.           rect2.y = gm.enemy[i].y;
  366.           if(LPRect.IntersectRect(rect1,rect2))
  367.           {
  368.             spriteDeadAction();
  369.             return;
  370.           }
  371.         }
  372.       }
  373.     }
  375.     for(i=gm.tortoise.length-1;i>=0;--i)
  376.     {
  377.       if(!gm.tortoise[i].isHidden)
  378.       {
  379.         if(gm.tortoise[i].isCheck)
  380.         {
  381.           rect2.x=gm.tortoise[i].x;
  382.           rect2.y=gm.tortoise[i].y+8;
  383.           if(LPRect.IntersectRect(rect1,rect2))
  384.           {
  385.             if(Math.abs(rect1.y+rect1.dy-(rect2.y))>6)
  386.             {
  387.               spriteDeadAction();
  388.               return;
  389.             }
  390.           }
  391.         }
  392.       }
  393.     }
  395.   }
  397.   private void mainSpriteDamage()
  398.   {
  399.     if(dy>=0)
  400.     {
  401.       int i;
  402.       rect1.y=y;
  403.       rect2.dx=16;
  404.       rect2.dy=16;
  405.       if(mainSpriteState==SMALL_SPRITE)
  406.       {
  407.         rect1.x=x;
  408.         rect1.dx=16;
  409.         rect1.dy=16;
  410.       }
  411.       else
  412.       {
  413.         rect1.x=8;
  414.         rect1.dx=20;
  415.         rect1.dy=32;
  416.       }
  418.       for(i=gm.enemy.length-1;i>=0;--i)
  419.       {
  420.         if(!gm.enemy[i].isHidden)
  421.         {
  422.           if(gm.enemy[i].isCheck)
  423.           {
  424.             if((gm.enemy[i].y>=y+rect1.dy)
  425.                &&(gm.enemy[i].y<=y+dy+rect1.dy)
  426.                &&(x>gm.enemy[i].x-13)&&(x<=gm.enemy[i].x+10))
  427.             {
  428.               gm.enemy[i].changeState();
  429.               if(gm.menu.isVolOn)
  430.               {
  431.                 gm.beatPlayer.replay();
  432.               }
  433.             }
  434.           }
  435.         }
  436.       }
  437.       for(i=gm.tortoise.length-1;i>=0;--i)
  438.       {
  439.         if(!gm.tortoise[i].isHidden)
  440.         {
  441.           if((gm.tortoise[i].y+8>=y+rect1.dy)
  442.              &&(gm.tortoise[i].y+8<=y+dy+rect1.dy)
  443.              &&(x>gm.tortoise[i].x-13)&&(x<=gm.tortoise[i].x+10))
  444.           {
  445.             dy=-8;
  446.             gm.tortoise[i].changeState();
  447.             if(gm.menu.isVolOn)
  448.             {
  449.               gm.beatPlayer.replay();
  450.             }
  451.           }
  452.         }
  453.       }
  454.     }
  455.   }
  457.   private boolean checkStaticSpriteCollision()
  458.   {
  459.     int i;
  460.     rect2.dx = 16;
  461.     rect2.dy = 16;
  462.     switch(mainSpriteState)
  463.     {
  464.       case SMALL_SPRITE:
  465.         rect1.x=x+2;
  466.         rect1.y=y;
  467.         rect1.dx=14;
  468.         rect1.dy=16;
  469.         break;
  470.       default:
  471.         rect1.x=x+8;
  472.         rect1.y=y+1;
  473.         rect1.dx=16;
  474.         rect1.dy=31;
  475.         break;
  476.     }
  478.     rect2.dx = 14;
  479.     rect2.dy = 16;
  481.     for(i=gm.mashRooms.length-1;i>=0;--i)
  482.     {
  483.       if(!gm.mashRooms[i].isHidden)
  484.       {
  485.         switch(mainSpriteState)
  486.         {
  487.           case SMALL_SPRITE:
  488.             rect2.x = gm.mashRooms[i].x;
  489.             rect2.y = gm.mashRooms[i].y;
  490.             if(LPRect.IntersectRect(rect1,rect2))
  491.             {
  492.               if(gm.menu.isVolOn)
  493.               {
  494.                 gm.beatPlayer.replay();
  495.               }
  496.               if(gm.mashRooms[i].frameCnt==6)
  497.               {
  498.                 gm.mashRooms[i].isHidden=true;
  499.                 mainSpriteState=GROW_SPRITE;
  500.                 growCnt=0;
  501.                 return true;
  502.               }
  503.               else if(gm.mashRooms[i].frameCnt==8)
  504.               {
  505.                 // add a person
  506.                 gm.mashRooms[i].isHidden=true;
  507.                 return true;
  508.               }
  509.             }
  510.             break;
  511.           case NORMAL_SPRITE:
  512.           case FIRE_SPRITE:
  513.             rect2.x=gm.mashRooms[i].x;
  514.             rect2.y=gm.mashRooms[i].y;
  515.             if(LPRect.IntersectRect(rect1,rect2))
  516.             {
  517.               if(gm.mashRooms[i].frameCnt==8)
  518.               {
  520.                 if(gm.menu.isVolOn)
  521.                 {
  522.                   gm.beatPlayer.replay();
  523.                 }
  524.                 // add a person
  525.                 gm.mashRooms[i].isHidden=true;
  526.                 return true;
  527.               }
  528.             }
  529.             break;
  530.         }
  531.       }
  532.     }
  534.     rect2.dy = 10;
  535.     rect2.dx = 10;
  536.     for(i=gm.flowers.length-1;i>=0;--i)
  537.     {
  538.       if(!gm.flowers[i].isHidden)
  539.       {
  540.         rect2.x=gm.flowers[i].x+3;
  541.         rect2.y=gm.flowers[i].y+2;
  542.         switch(mainSpriteState)
  543.         {
  544.           case SMALL_SPRITE:
  545.             if (LPRect.IntersectRect(rect1, rect2))
  546.             {
  547.               if(gm.menu.isVolOn)
  548.               {
  549.                 gm.beatPlayer.replay();
  550.               }
  551.               gm.flowers[i].isHidden = true;
  552.               mainSpriteState = GROW_SPRITE;
  553.               return true;
  554.             }
  555.             break;
  556.           case NORMAL_SPRITE:
  557.             if(LPRect.IntersectRect(rect1,rect2))
  558.             {
  559.               if(gm.menu.isVolOn)
  560.               {
  561.                 gm.beatPlayer.replay();
  562.               }
  563.               gm.flowers[i].isHidden=true;
  564.               mainSpriteState=BECOME_FIRE;
  565.               return true;
  566.             }
  567.             break;
  568.           case FIRE_SPRITE:
  569.             if (LPRect.IntersectRect(rect1, rect2))
  570.             {
  571.               if(gm.menu.isVolOn)
  572.               {
  573.                 gm.beatPlayer.replay();
  574.               }
  575.               gm.flowers[i].isHidden = true;
  576.               mainSpriteState = FIRE_SPRITE;
  577.               return true;
  578.             }
  579.             break;
  580.         }
  581.       }
  582.     }
  583.     rect2.dx = 14;
  584.     rect2.dy = 14;
  585.     switch(gm.gameState)
  586.     {
  587.       case MarioGameManage.GAMESTATE_GAMELOOP:
  588.         for(i=gm.staticGold.length-1;i>=0;--i)
  589.         {
  590.           if(!gm.staticGold[i].isHidden)
  591.           {
  592.             rect2.x = gm.staticGold[i].x;
  593.             rect2.y = gm.staticGold[i].y;
  594.             if(LPRect.IntersectRect(rect1,rect2))
  595.             {
  596.               gm.staticGold[i].isHidden = true;
  597.               if(++gm.goldNum==100)
  598.               {
  599.                 gm.goldNum = 0;
  600.               }
  601.               if(gm.menu.isVolOn)
  602.               {
  603.                 gm.beatPlayer.replay();
  604.               }
  605.             }
  606.           }
  607.         }
  608.         break;
  609.     }
  610.     return false;
  611.   }
  613.   public void judgeKeyCode(int keyCode, int gameKeyCode)
  614.   {
  615.     switch (gameKeyCode)
  616.     {
  617.       case Canvas.UP:
  618.         if (dy == 0)
  619.         {
  620.           if ( ( ( (allAction & LPKeyMask.MASK_KEY_UP) == 0)
  621.                 && ( (allAction & LPKeyMask.MASK_KEY_UP_FLAG) == 0)))
  622.           {
  623.             allAction |= LPKeyMask.MASK_KEY_UP_FLAG | LPKeyMask.MASK_KEY_UP;
  624.             dy -= 18;
  625.           }
  626.         }
  627.         break;
  628.       case Canvas.FIRE:
  629.         if((((allAction&LPKeyMask.MASK_KEY_OK)==0)
  630.             &&((allAction&LPKeyMask.MASK_KEY_OK_FLAG)==0)))
  631.         {
  632.           allAction|=LPKeyMask.MASK_KEY_OK|LPKeyMask.MASK_KEY_OK_FLAG;
  633.         }
  634.         break;
  635.       case Canvas.LEFT:
  636.         allAction |= LPKeyMask.MASK_KEY_LEFT;
  637.         break;
  638.       case Canvas.RIGHT:
  639.         allAction |= LPKeyMask.MASK_KEY_RIGHT;
  640.         break;
  641.       default:
  642.         switch (keyCode)
  643.         {
  644.           case Canvas.KEY_NUM2:
  645.             if(dy==0)
  646.             {
  647.               if((((allAction&LPKeyMask.MASK_KEY_UP)==0)
  648.                   &&((allAction&LPKeyMask.MASK_KEY_UP_FLAG)==0)))
  649.               {
  650.                 allAction|=LPKeyMask.MASK_KEY_UP_FLAG|LPKeyMask.MASK_KEY_UP;
  651.                 dy-=18;
  652.               }
  653.             }
  654.             break;
  655.           case Canvas.KEY_NUM4: //left
  656.             allAction |= LPKeyMask.MASK_KEY_LEFT;
  657.             break;
  658.           case Canvas.KEY_NUM6: //right
  659.             allAction |= LPKeyMask.MASK_KEY_RIGHT;
  660.             break;
  661.           case Canvas.KEY_NUM5:
  662.             if((((allAction&LPKeyMask.MASK_KEY_OK)==0)
  663.                 &&((allAction&LPKeyMask.MASK_KEY_OK_FLAG)==0)))
  664.             {
  665.               allAction|=LPKeyMask.MASK_KEY_OK|LPKeyMask.MASK_KEY_OK_FLAG;
  666.             }
  667.             break;
  668.         }
  669.         break;
  670.     }
  671.   }
  673.   public void freeKey(int keyCode, int gameKeyCode)
  674.   {
  675.     switch (gameKeyCode)
  676.     {
  677.       case Canvas.FIRE:
  678.         allAction &= ~LPKeyMask.MASK_KEY_OK;
  679.         break;
  680.       case Canvas.UP:
  681.         allAction &= ~LPKeyMask.MASK_KEY_UP;
  682.         break;
  683.       case Canvas.DOWN:
  684.         allAction &= ~LPKeyMask.MASK_KEY_DOWN;
  685.         break;
  686.       case Canvas.LEFT:
  687.         allAction &= ~LPKeyMask.MASK_KEY_LEFT;
  688.         break;
  689.       case Canvas.RIGHT:
  690.         allAction &= ~LPKeyMask.MASK_KEY_RIGHT;
  691.         break;
  692.       default:
  693.         switch (keyCode)
  694.         {
  695.           case Canvas.KEY_NUM4: //left
  696.             allAction &= ~LPKeyMask.MASK_KEY_LEFT;
  697.             break;
  698.           case Canvas.KEY_NUM6:
  699.             allAction &= ~LPKeyMask.MASK_KEY_RIGHT; //right
  700.             break;
  701.           case Canvas.KEY_NUM2:
  702.             allAction &= ~LPKeyMask.MASK_KEY_UP; //jump
  703.             break;
  704.           case Canvas.KEY_NUM8:
  705.             allAction &= ~LPKeyMask.MASK_KEY_DOWN;
  706.             break;
  707.           case Canvas.KEY_NUM5:
  708.             allAction &= ~LPKeyMask.MASK_KEY_OK;
  709.             break;
  710.         }
  711.         break;
  712.     }
  713.   }
  715.   private void walk()
  716.   {
  717.     frameCnt++;
  718.     if (this.frameCnt > 3 + offset || this.frameCnt < 1 + offset)
  719.     {
  720.       this.frameCnt = 1 + offset;
  721.     }
  722.   }
  724.   private boolean checkTileCollisionVertical()
  725.   {
  726.     if (mainSpriteState == SMALL_SPRITE)
  727.     {
  728.       // 16X16
  729.       if (this.dy > 0)
  730.       {
  731.         isJumpOver = true;
  732.         for (int i = (y + this.judgeMap.y+15) /
  733.              this.judgeMap.tileSize+1;
  734.              i <= (y + this.judgeMap.y + dy) / this.judgeMap.tileSize+1; i++)
  735.         {
  736.           if (i < 0 || i > judgeMap.h - 1)
  737.           {
  738.             continue;
  739.           }
  740.           int xTile1 = (x + this.judgeMap.x + 2) / this.judgeMap.tileSize;
  741.           int xTile2 = (x + this.judgeMap.x + 14) / this.judgeMap.tileSize;
  742.           if (xTile2 > this.judgeMap.w - 1 || xTile1 < 0)
  743.           {
  744.             return false;
  745.           }
  746.           if ( ( (this.judgeMap.mapArray[i][xTile1] >> 8) & 0x02) == 0x02)
  747.           {
  748.             dy = (i - 1) * this.judgeMap.tileSize - (y + this.judgeMap.y);
  749.             allAction &= ~LPKeyMask.MASK_KEY_UP_FLAG;
  750.             return true;
  751.           }
  752.           if ( ( (this.judgeMap.mapArray[i][xTile2] >> 8) & 0x02) == 0x02)
  753.           {
  754.             dy = (i - 1) * this.judgeMap.tileSize - (y + this.judgeMap.y);
  755.             allAction &= ~LPKeyMask.MASK_KEY_UP_FLAG;
  756.             return true;
  757.           }
  758.         }
  759.       }
  760.       else if (dy < 0)
  761.       {
  762.         for (int i = (y + this.judgeMap.y + dy) / this.judgeMap.tileSize;
  763.              i <= (y + this.judgeMap.y) / this.judgeMap.tileSize; i++)
  764.         {
  765.           if (i < 0 || i > judgeMap.h - 1)
  766.           {
  767.             continue;
  768.           }
  769.           int xTile1 = (x + this.judgeMap.x + 2) / this.judgeMap.tileSize;
  770.           int xTile2 = (x + this.judgeMap.x + 14) / this.judgeMap.tileSize;
  771.           if (xTile2 > this.judgeMap.w - 1 || xTile1 < 0)
  772.           {
  773.             return false;
  774.           }
  775.           if ( ( (this.judgeMap.mapArray[i][xTile1] >> 8) & 0x08) == 0x08)
  776.           {
  777.             dy = 0;
  778.             allAction &= ~LPKeyMask.MASK_KEY_UP_FLAG;
  779.             if(isJumpOver)
  780.             {
  781.               changeUpSpriteState();
  782.               isJumpOver =false;
  783.             }
  784.             return true;
  785.           }
  786.           if ( ( (this.judgeMap.mapArray[i][xTile2] >> 8) & 0x08) == 0x08)
  787.           {
  788.             dy = 0;
  789.             if(isJumpOver)
  790.             {
  791.               changeUpSpriteState();
  792.               isJumpOver =false;
  793.             }
  794.             allAction &= ~LPKeyMask.MASK_KEY_UP_FLAG;
  795.             return true;
  796.           }
  798.           if ( ( (this.judgeMap.mapArray[i][xTile1] >> 8) & 0x01) == 0x01)
  799.           {
  800.             dy = 0;
  801.             allAction &= ~LPKeyMask.MASK_KEY_UP_FLAG;
  802.             return true;
  803.           }
  804.           if ( ( (this.judgeMap.mapArray[i][xTile2] >> 8) & 0x01) == 0x01)
  805.           {
  806.             dy = 0;
  807.             allAction &= ~LPKeyMask.MASK_KEY_UP_FLAG;
  808.             return true;
  809.           }
  810.         }
  811.       }
  812.       else
  813.       {
  814.         isJumpOver = true;
  815.       }
  816.     }
  817.     else
  818.     {
  819.       //32 X 32
  820.       if (this.dy > 0)
  821.       {
  822.         isJumpOver = true;
  823.         for (int i = (y + this.judgeMap.y+15) /
  824.              this.judgeMap.tileSize + 2;
  825.              i <= (y + this.judgeMap.y + dy) / this.judgeMap.tileSize + 2; i++)
  826.         {
  827.           if (i < 0 || i > judgeMap.h - 1)
  828.           {
  829.             continue;
  830.           }
  831.           int xTile1 = (x + this.judgeMap.x + 12) / this.judgeMap.tileSize;
  832.           int xTile2 = (x + this.judgeMap.x + 20) / this.judgeMap.tileSize;
  833.           if (xTile2 > this.judgeMap.w - 1 || xTile1 < 0)
  834.           {
  835.             return false;
  836.           }
  838.           if ( ( (this.judgeMap.mapArray[i][xTile1] >> 8) & 0x02) == 0x02)
  839.           {
  840.             dy = (i - 2) * this.judgeMap.tileSize - (y + this.judgeMap.y);
  841.             allAction &= ~LPKeyMask.MASK_KEY_UP_FLAG;
  842.             return true;
  843.           }
  844.           if ( ( (this.judgeMap.mapArray[i][xTile2] >> 8) & 0x02) == 0x02)
  845.           {
  846.             dy = (i - 2) * this.judgeMap.tileSize - (y + this.judgeMap.y);
  847.             allAction &= ~LPKeyMask.MASK_KEY_UP_FLAG;
  848.             return true;
  849.           }
  850.         }
  851.       }
  852.       else if (dy < 0)
  853.       {
  854.         for (int i = (y + this.judgeMap.y + dy) / this.judgeMap.tileSize;
  855.              i <= (y + this.judgeMap.y ) / this.judgeMap.tileSize; i++)
  856.         {
  857.           if (i < 0 || i > judgeMap.h - 1)
  858.           {
  859.             continue;
  860.           }
  861.           int xTile1 = (x + this.judgeMap.x + 12) / this.judgeMap.tileSize;
  862.           int xTile2 = (x + this.judgeMap.x + 20) / this.judgeMap.tileSize;
  863.           if (xTile2 > this.judgeMap.w - 1 || xTile1 < 0)
  864.           {
  865.             return false;
  866.           }
  867.           if ( ( (this.judgeMap.mapArray[i][xTile1] >> 8) & 0x08) == 0x08)
  868.           {
  869.             dy = 0;
  870.             allAction &= ~LPKeyMask.MASK_KEY_UP_FLAG;
  871.             if (isJumpOver)
  872.             {
  873.               judgeMap.mapArray[i][xTile1] = judgeMap.mapArray[0][0];
  874.               gm.createBrokenBrick(x + 10, y - 5, -5, -12);
  875.               gm.createBrokenBrick(x + 10, y - 5, 5, -12);
  876.               gm.createBrokenBrick(x + 10, y - 5, -5, -6);
  877.               gm.createBrokenBrick(x + 10, y - 5, 5, -6);
  878.               isJumpOver = false;
  879.             }
  881.             return true;
  882.           }
  883.           if ( ( (this.judgeMap.mapArray[i][xTile2] >> 8) & 0x08) == 0x08)
  884.           {
  885.             dy = 0;
  886.             allAction &= ~LPKeyMask.MASK_KEY_UP_FLAG;
  887.             if (isJumpOver)
  888.             {
  889.               judgeMap.mapArray[i][xTile2] = judgeMap.mapArray[0][0];
  890.               gm.createBrokenBrick(x + 10, y - 5, -5, -12);
  891.               gm.createBrokenBrick(x + 10, y - 5, 5, -12);
  892.               gm.createBrokenBrick(x + 10, y - 5, -5, -6);
  893.               gm.createBrokenBrick(x + 10, y - 5, 5, -6);
  894.               isJumpOver = false;
  895.             }
  896.             return true;
  897.           }
  899.           if ( ( (this.judgeMap.mapArray[i][xTile1] >> 8) & 0x01) == 0x01)
  900.           {
  901.             dy = 0;
  902.             allAction &= ~LPKeyMask.MASK_KEY_UP_FLAG;
  903.             return true;
  904.           }
  905.           if ( ( (this.judgeMap.mapArray[i][xTile2] >> 8) & 0x01) == 0x01)
  906.           {
  907.             dy = 0;
  908.             allAction &= ~LPKeyMask.MASK_KEY_UP_FLAG;
  909.             return true;
  910.           }
  911.         }
  912.       }
  913.       else
  914.       {
  915.         isJumpOver = true;
  916.       }
  917.     }
  918.     return false;
  919.   }
  921.   private boolean checkTileCollisionHorizon()
  922.   {
  923.     int i;
  924.     if (mainSpriteState == SMALL_SPRITE)
  925.     {
  926.       rect1.y = this.y + this.judgeMap.y;
  927.       rect1.dx = 16;
  928.       rect1.dy = 16;
  930.       rect2.dx = 16;
  931.       rect2.dy = 16;
  933.       rect1.x = x + judgeMap.x + dx;
  934.       if (dx<0)
  935.       {
  936.         i = (x + judgeMap.x + dx) / judgeMap.tileSize;
  937.       }
  938.       else
  939.       {
  940.         i = (x + judgeMap.x + dx) / judgeMap.tileSize + 1;
  941.       }
  942.       if (i < 0 || i > this.judgeMap.w - 1)
  943.         return false;
  944.       int yTile1 = (y + judgeMap.y) / judgeMap.tileSize;
  945.       int yTile2 = (y + judgeMap.y) / judgeMap.tileSize+1;
  946.       if (yTile1 < 0 || yTile2 > judgeMap.h - 1)
  947.         return false;
  948.       if(dx>0)
  949.       {
  950.         if(((this.judgeMap.mapArray[yTile1][i]>>8)&0x10)==0x10)
  951.         {
  952.           rect2.x=i*16;
  953.           rect2.y=yTile1*16;
  954.           if(LPRect.IntersectRect(rect1,rect2))
  955.           {
  956.             return true;
  957.           }
  958.         }
  959.       }
  960.       if(((this.judgeMap.mapArray[yTile1][i]>>8)&0x04)==0x04)
  961.       {
  962.         rect2.x = i * 16;
  963.         rect2.y = yTile1 * 16;
  964.         if (LPRect.IntersectRect(rect1, rect2))
  965.         {
  966.           return true;
  967.         }
  968.       }
  969.       if ( ( (this.judgeMap.mapArray[yTile2][i] >> 8) & 0x04) == 0x04)
  970.       {
  971.         rect2.x = i * 16;
  972.         rect2.y = yTile2 * 16;
  973.         if (LPRect.IntersectRect(rect1, rect2))
  974.         {
  975.           return true;
  976.         }
  977.       }
  978.     }
  979.     else
  980.     {
  981.       rect1.y = this.y + this.judgeMap.y+1;
  982.       rect1.dx = 16;
  983.       rect1.dy = 31;
  985.       rect2.dx = 16;
  986.       rect2.dy = 16;
  988.       if (dx<0)
  989.       {
  990.         rect1.x = x + judgeMap.x +6+dx;
  991.         i = (x + judgeMap.x +6+dx) / judgeMap.tileSize;
  992.       }
  993.       else
  994.       {
  995.         rect1.x = x + judgeMap.x +20+dx;
  996.         i = (x + judgeMap.x +20+dx) / judgeMap.tileSize ;
  997.       }
  998.       if (i < 0 || i > this.judgeMap.w - 1)
  999.         return false;
  1000.       int yTile1 = (y + judgeMap.y) / judgeMap.tileSize;
  1001.       int yTile2 = (y + judgeMap.y) / judgeMap.tileSize + 1;
  1002.       int yTile3 = (y + judgeMap.y) / judgeMap.tileSize + 2;
  1003.       if (yTile1 < 0 || yTile3 > judgeMap.h - 1)
  1004.         return false;
  1006.       if(dx>0)
  1007.       {
  1008.         boolean isCheck = false;;
  1009.         if(((this.judgeMap.mapArray[yTile1][i]>>8)&0x10)==0x10)
  1010.         {
  1011.           rect2.x=i*16;
  1012.           rect2.y=yTile1*16;
  1013.           if(LPRect.IntersectRect(rect1,rect2))
  1014.           {
  1015.            isCheck = true;
  1016.           }
  1017.         }
  1018.         if(isCheck)
  1019.         {
  1020.           if(((this.judgeMap.mapArray[yTile2][i]>>8)&0x10)==0x10)
  1021.           {
  1022.             rect2.x=i*16;
  1023.             rect2.y=yTile2*16;
  1024.             if(LPRect.IntersectRect(rect1,rect2))
  1025.             {
  1026.               return true;
  1027.             }
  1028.           }
  1029.         }
  1030.       }
  1031.       if(((this.judgeMap.mapArray[yTile1][i]>>8)&0x04)==0x04)
  1032.       {
  1033.         rect2.x = i * 16;
  1034.         rect2.y = yTile1 * 16;
  1035.         if (LPRect.IntersectRect(rect1, rect2))
  1036.         {
  1037.           return true;
  1038.         }
  1039.       }
  1040.       if ( ( (this.judgeMap.mapArray[yTile2][i] >> 8) & 0x04) == 0x04)
  1041.       {
  1042.         rect2.x = i * 16;
  1043.         rect2.y = yTile2 * 16;
  1044.         if (LPRect.IntersectRect(rect1, rect2))
  1045.         {
  1046.           return true;
  1047.         }
  1048.       }
  1049.       if ( ( (this.judgeMap.mapArray[yTile3][i] >> 8) & 0x04) == 0x04)
  1050.       {
  1051.         rect2.x = i * 16;
  1052.         rect2.y = yTile3 * 16;
  1053.         if (LPRect.IntersectRect(rect1, rect2))
  1054.         {
  1055.           return true;
  1056.         }
  1057.       }
  1058.     }
  1059.     return false;
  1060.   }
  1062.   private void fire()
  1063.   {
  1064.     if(isLeft)
  1065.     {
  1066.       gm.createBullet(x+16,y+16,-(MOVE_SPEED+4),0);
  1067.     }
  1068.     else
  1069.     {
  1070.       gm.createBullet(x+16,y+16,(MOVE_SPEED+4),0);
  1071.     }
  1072.   }
  1074.   private boolean checkSpriteCollisionVertical()
  1075.   {
  1076.     int i;
  1077.     if (mainSpriteState == SMALL_SPRITE)
  1078.     {
  1079.       if (dy > 0)
  1080.       {
  1081.         isJumpOver = true;
  1082.         switch(gm.gameState)
  1083.         {
  1084.           case MarioGameManage.GAMESTATE_GAMELOOP:
  1085.             for(i=gm.brick.length-1;i>=0;--i)
  1086.             {
  1087.               if(!gm.brick[i].isHidden)
  1088.               {
  1089.                 if(((y+16)<=gm.brick[i].y)&&
  1090.                    ((y+dy+16)>=gm.brick[i].y)
  1091.                    &&(x>=gm.brick[i].x-13)&&(x<=gm.brick[i].x+10))
  1092.                 {
  1093.                   dy=gm.brick[i].y-(y+16);
  1094.                   allAction&=~LPKeyMask.MASK_KEY_UP_FLAG;
  1095.                   return true;
  1096.                 }
  1097.               }
  1098.             }
  1099.             for(i=gm.stick.length-1;i>=0;--i)
  1100.             {
  1101.               if(!gm.stick[i].isHidden)
  1102.               {
  1103.                 if(((y+16)<=gm.stick[i].y)&&
  1104.                    ((y+dy+16)>=gm.stick[i].y)
  1105.                    &&(x>=gm.stick[i].x-13)&&(x<=gm.stick[i].x+42))
  1106.                 {
  1107.                   gm.stick[i].isMainSpriteMove=true;
  1108.                   gm.stick[i].isDown = true;
  1109.                   dy=gm.stick[i].y-(y+16);
  1110.                   this.allAction&=~LPKeyMask.MASK_KEY_UP_FLAG;
  1111.                   return true;
  1112.                 }
  1113.                 else
  1114.                 {
  1115.                   gm.stick[i].isMainSpriteMove=false;
  1116.                   gm.stick[i].isDown = false;
  1117.                 }
  1118.               }
  1119.             }
  1120.             for(i=gm.bridge.length-1;i>=0;--i)
  1121.             {
  1122.               if(!gm.bridge[i].isHidden)
  1123.               {
  1124.                 if(((y+16)<=gm.bridge[i].y)&&
  1125.                    ((y+dy+16)>=gm.bridge[i].y)
  1126.                    &&(x>=gm.bridge[i].x-13)&&(x<=gm.bridge[i].x+10))
  1127.                 {
  1128.                   gm.bridge[i].isDown=true;
  1129.                   dy=gm.bridge[i].y-(y+16);
  1130.                   allAction&=~LPKeyMask.MASK_KEY_UP_FLAG;
  1131.                   return true;
  1132.                 }
  1133.               }
  1134.             }
  1135.             break;
  1136.         }
  1137.       }
  1138.       else if(dy<0)
  1139.       {
  1140.         switch(gm.gameState)
  1141.         {
  1142.           case MarioGameManage.GAMESTATE_GAMELOOP:
  1143.             for(i=gm.brick.length-1;i>=0;--i)
  1144.             {
  1145.               if(((y)>=gm.brick[i].y+16)&&
  1146.                  ((y+dy)<=gm.brick[i].y+16)
  1147.                  &&(x>=gm.brick[i].x-13)&&(x<=gm.brick[i].x+10))
  1148.               {
  1149.                 dy=gm.brick[i].y+16-y;
  1150.                 if(isJumpOver)
  1151.                 {
  1152.                   if(gm.brick[i].frameCnt!=0)
  1153.                   {
  1154.                     changeUpSpriteState();
  1155.                   }
  1156.                   gm.brick[i].createGem(gm);
  1157.                   isJumpOver=false;
  1158.                 }
  1159.                 allAction&=~LPKeyMask.MASK_KEY_UP_FLAG;
  1160.                 return true;
  1161.               }
  1162.             }
  1163.             break;
  1164.         }
  1165.       }
  1166.       else
  1167.       {
  1168.         isJumpOver = true;
  1169.       }
  1170.     }
  1171.     else
  1172.     {
  1173.       if (dy > 0)
  1174.       {
  1175.         isJumpOver = true;
  1176.         switch(gm.gameState)
  1177.         {
  1178.           case MarioGameManage.GAMESTATE_GAMELOOP:
  1179.             for(i=gm.brick.length-1;i>=0;--i)
  1180.             {
  1181.               if(!gm.brick[i].isHidden)
  1182.               {
  1183.                 if(((y+32)<=gm.brick[i].y)&&
  1184.                    ((y+dy+32)>=gm.brick[i].y)
  1185.                    &&(x>=gm.brick[i].x-20)&&(x<=gm.brick[i].x+6))
  1186.                 {
  1187.                   dy=gm.brick[i].y-(y+32);
  1188.                   allAction&=~LPKeyMask.MASK_KEY_UP_FLAG;
  1189.                   return true;
  1190.                 }
  1191.               }
  1192.             }
  1193.             for(i=gm.stick.length-1;i>=0;--i)
  1194.             {
  1195.               if(!gm.stick[i].isHidden)
  1196.               {
  1197.                 if(((y+32)<=gm.stick[i].y)&&
  1198.                    ((y+dy+32)>=gm.stick[i].y)
  1199.                    &&(x>=gm.stick[i].x-20)&&(x<=gm.stick[i].x+38))
  1200.                 {
  1201.                   gm.stick[i].isMainSpriteMove=true;
  1202.                   dy=gm.stick[i].y-(y+32);
  1203.                   this.allAction&=~LPKeyMask.MASK_KEY_UP_FLAG;
  1204.                   return true;
  1205.                 }
  1206.                 else
  1207.                 {
  1208.                   gm.stick[i].isMainSpriteMove=false;
  1209.                 }
  1210.               }
  1211.             }
  1212.             for(i=gm.bridge.length-1;i>=0;--i)
  1213.             {
  1214.               if(!gm.bridge[i].isHidden)
  1215.               {
  1216.                 if(((y+32)<=gm.bridge[i].y)&&
  1217.                    ((y+dy+32)>=gm.bridge[i].y)
  1218.                    &&(x>=gm.bridge[i].x-20)&&(x<=gm.bridge[i].x+6))
  1219.                 {
  1220.                   gm.bridge[i].isDown = true;
  1221.                   dy=gm.bridge[i].y-(y+32);
  1222.                   allAction&=~LPKeyMask.MASK_KEY_UP_FLAG;
  1223.                   return true;
  1224.                 }
  1225.               }
  1226.             }
  1227.             break;
  1228.         }
  1229.       }
  1230.       else if(dy<0)
  1231.       {
  1232.         switch(gm.gameState)
  1233.         {
  1234.           case MarioGameManage.GAMESTATE_GAMELOOP:
  1235.             for(i=gm.brick.length-1;i>=0;--i)
  1236.             {
  1237.               if(((y)>=gm.brick[i].y+16)&&
  1238.                  ((y+dy)<=gm.brick[i].y+16)
  1239.                  &&(x>=gm.brick[i].x-20)&&(x<=gm.brick[i].x+6))
  1240.               {
  1241.                 dy=gm.brick[i].y+16-y;
  1242.                 if(isJumpOver)
  1243.                 {
  1244.                   gm.brick[i].createGem(gm);
  1245.                   isJumpOver=false;
  1246.                 }
  1247.                 allAction&=~LPKeyMask.MASK_KEY_UP_FLAG;
  1248.                 return true;
  1249.               }
  1250.             }
  1251.             break;
  1252.         }
  1253.       }
  1254.       else
  1255.       {
  1256.         isJumpOver = true;
  1257.       }
  1258.     }
  1259.     return false;
  1260.   }
  1263.   private boolean checkSpriteCollisionHorizon()
  1264.   {
  1265.     if(gm.gameState==MarioGameManage.GAMESTATE_GAMELOOP)
  1266.     {
  1267.       int i;
  1268.       if(mainSpriteState==SMALL_SPRITE)
  1269.       {
  1270.         rect1.x=x;
  1271.         rect1.y=y;
  1272.         rect1.dx=16;
  1273.         rect1.dy=16;
  1274.       }
  1275.       else
  1276.       {
  1277.         rect1.x=x+6;
  1278.         rect1.y=y;
  1279.         rect1.dx=16;
  1280.         rect1.dy=32;
  1281.       }
  1282.       for(i=gm.tortoise.length-1;i>=0;--i)
  1283.       {
  1284.         if(!gm.tortoise[i].isHidden)
  1285.         {
  1286.           if(gm.tortoise[i].isPushable)
  1287.           {
  1288.             rect2.x=gm.tortoise[i].x;
  1289.             rect2.y=gm.tortoise[i].y+8;
  1290.             rect2.dx=16;
  1291.             rect2.dy=16;
  1292.             if(LPRect.IntersectRect(rect1,rect2))
  1293.             {
  1294.               gm.tortoise[i].changeState();
  1295.             }
  1296.           }
  1297.         }
  1298.       }
  1299.       rect1.x+=dx;
  1300.       for(i=gm.brick.length-1;i>=0;--i)
  1301.       {
  1302.         if(!gm.brick[i].isHidden)
  1303.         {
  1304.           rect2.x=gm.brick[i].x;
  1305.           rect2.y=gm.brick[i].y;
  1306.           rect2.dx=16;
  1307.           rect2.dy=16;
  1308.           if(LPRect.IntersectRect(rect1,rect2))
  1309.           {
  1310.             return true;
  1311.           }
  1312.         }
  1313.       }
  1314.     }
  1315.     return false;
  1316.   }
  1318.   private void checkBulletDamage()
  1319.   {
  1320.     int i,j;
  1321.     rect1.dx = 8;
  1322.     rect1.dy = 8;
  1323.     rect2.dx = 16;
  1324.     rect2.dy = 16;
  1325.     for(i=gm.bullet.length-1;i>=0;--i)
  1326.     {
  1327.       label_1:
  1328.       if(!gm.bullet[i].isHidden)
  1329.       {
  1330.         rect1.x = gm.bullet[i].x;
  1331.         rect1.y = gm.bullet[i].y;
  1332.         for(j=gm.enemy.length-1;j>=0;--j)
  1333.         {
  1334.           if(!gm.enemy[j].isHidden)
  1335.           {
  1336.             if(gm.enemy[j].isCheck)
  1337.             {
  1338.               rect2.x=gm.enemy[j].x;
  1339.               rect2.y=gm.enemy[j].y;
  1340.               if(LPRect.IntersectRect(rect1,rect2))
  1341.               {
  1342.                 gm.enemy[j].changeDirection();
  1343.                 gm.bullet[i].isHidden = true;
  1344.                 break label_1;
  1345.               }
  1346.             }
  1347.           }
  1348.         }
  1349.         for(j=gm.tortoise.length-1;j>=0;--j)
  1350.         {
  1351.           if(!gm.tortoise[j].isHidden)
  1352.           {
  1353.             if(gm.tortoise[j].isCheck)
  1354.             {
  1355.               rect2.x = gm.tortoise[j].x;
  1356.               rect2.y = gm.tortoise[j].y+8;
  1357.               if(LPRect.IntersectRect(rect1,rect2))
  1358.               {
  1359.                 gm.tortoise[j].changeDirection();
  1360.                 gm.bullet[i].isHidden = true;
  1361.                 break label_1;
  1362.               }
  1363.             }
  1364.           }
  1365.         }
  1366.       }
  1367.     }
  1368.   }
  1370.   public void init()
  1371.   {
  1372.     x = 0;
  1373.     y = 0;
  1374.     dy = 0;
  1375.     dx = 0;
  1376.     bgdx = 0;
  1377.     bgdy = 0;
  1378.     isLeft = false;
  1379.     allAction = 0;
  1380.     mainSpriteState = SMALL_SPRITE;
  1381.     distance = 0;
  1382.     isJumpOver = true;
  1383.     isProtected = false;
  1384.     isHidden = false;
  1385.   }
  1387.   private void changeUpSpriteState()
  1388.   {
  1389.     int i;
  1390.     rect1.x = x;
  1391.     rect1.y = y-20;
  1393.     rect1.dx = 16;
  1394.     rect1.dy = 16;
  1395.     rect2.dx = 16;
  1396.     rect2.dy = 16;
  1397.     for(i=gm.mashRooms.length-1;i>=0;--i)
  1398.     {
  1399.       if(!gm.mashRooms[i].isHidden)
  1400.       {
  1401.         rect2.x = gm.mashRooms[i].x;
  1402.         rect2.y = gm.mashRooms[i].y;
  1403.         if(LPRect.IntersectRect(rect1,rect2))
  1404.         {
  1405.           gm.mashRooms[i].changeDirection();
  1406.         }
  1407.       }
  1408.     }
  1409.     for(i=gm.enemy.length-1;i>=0;--i)
  1410.     {
  1411.       if(!gm.enemy[i].isHidden)
  1412.       {
  1413.         if(gm.enemy[i].isCheck)
  1414.         {
  1415.           rect2.x=gm.enemy[i].x;
  1416.           rect2.y=gm.enemy[i].y;
  1417.           if(LPRect.IntersectRect(rect1,rect2))
  1418.           {
  1419.             gm.enemy[i].changeDirection();
  1420.           }
  1421.         }
  1422.       }
  1423.     }
  1424.     for(i=gm.tortoise.length-1;i>=0;--i)
  1425.     {
  1426.       if(!gm.tortoise[i].isHidden)
  1427.       {
  1428.         if(gm.tortoise[i].isCheck)
  1429.         {
  1430.           rect2.x=gm.tortoise[i].x;
  1431.           rect2.y=gm.tortoise[i].y;
  1432.           if(LPRect.IntersectRect(rect1,rect2))
  1433.           {
  1434.             gm.tortoise[i].changeDirection();
  1435.           }
  1436.         }
  1437.       }
  1438.     }
  1439.   }
  1441.   public void readData(DataInputStream dis)
  1442.     throws java.io.IOException
  1443.   {
  1444.     super.readData(dis);
  1445.     dx = dis.readInt();
  1446.     dy = dis.readInt();
  1447.     bgdx = dis.readInt();
  1448.     bgdy = dis.readInt();
  1449.     growCnt = dis.readInt();
  1450.     //allAction = dis.readInt();
  1451.     mainSpriteState = dis.readInt();
  1452.     becomeCnt = dis.readInt();
  1453.     protectInterval = dis.readInt();
  1454.     protectCnt = dis.readInt();
  1455.     isLeft = dis.readBoolean();
  1456.     isProtected = dis.readBoolean();
  1457.     deadCnt = dis.readInt();
  1458.     distance = dis.readInt();
  1459.   }
  1461.   public void writeData(DataOutputStream dos)
  1462.     throws java.io.IOException
  1463.   {
  1464.     super.writeData(dos);
  1465.     dos.writeInt(dx);
  1466.     dos.writeInt(dy);
  1467.     dos.writeInt(bgdx);
  1468.     dos.writeInt(bgdy);
  1469.     dos.writeInt(growCnt);
  1470.     dos.writeInt(mainSpriteState);
  1471.     dos.writeInt(becomeCnt);
  1472.     dos.writeInt(protectInterval);
  1473.     dos.writeInt(protectCnt);
  1474.     dos.writeBoolean(isLeft);
  1475.     dos.writeBoolean(isProtected);
  1476.     dos.writeInt(deadCnt);
  1477.     dos.writeInt(distance);
  1478.   }
  1480. // property
  1481. //pubilc
  1482.   public int dx;
  1483.   public int dy;
  1484.   public int bgdx;
  1485.   public int bgdy;
  1486.   public LPMaps judgeMap;
  1487.   public int growCnt;
  1488.   public int allAction;
  1489.   public int mainSpriteState;
  1490.   public int becomeCnt;
  1491. //private
  1492.   private LPRect rect1 = new LPRect();
  1493.   private LPRect rect2 = new LPRect();
  1494.   private boolean isJumpOver;
  1495.   private int protectInterval;
  1496.   private int protectCnt;
  1497.   private MarioGameManage gm;
  1498.   private boolean isLeft;
  1499.   private boolean isProtected;
  1500.   private int deadCnt;
  1501.   private int distance;
  1502.   //final
  1503.   private static final int MOVE_SPEED = 6;
  1504.   // main sprite's state
  1505.   public static final int SMALL_SPRITE = 0x01;
  1506.   public static final int NORMAL_SPRITE = 0x02;
  1507.   public static final int FIRE_SPRITE = 0x04;
  1508.   public static final int GROW_SPRITE = 0x08;
  1509.   public static final int BECOME_FIRE = 0x10;
  1510.   public static final int DEAD_SPRITE = 0x20;
  1511.   public static final int BECOME_SMALL = 0x40;
  1512. }