MarioBrick.java
上传用户:gyyuli
上传日期:2013-07-09
资源大小:3050k
文件大小:12k
源码类别:

J2ME

开发平台:

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.  */
  12. package mario;
  13. import lipeng.LPSprite;
  14. import javax.microedition.lcdui.Graphics;
  15. import lipeng.LPImageManage;
  16. import lipeng.LPRect;
  17. import java.io.DataInputStream;
  18. import java.io.DataOutputStream;
  19. import java.io.IOException;
  20. public class MarioBrick extends LPSprite
  21. {
  22.   public MarioBrick(int x,int y)
  23.   {
  24.     this.x = x;
  25.     this.y = y;
  26.   }
  27.   public void createGem(MarioGameManage gm)
  28.   {
  29.   }
  30. }
  31. class MarioBrickHidden extends MarioBrick
  32. {
  33.   public MarioBrickHidden(int x,int y)
  34.   {
  35.     super(x,y);
  36.     isHidden = true;
  37.   }
  38.   public void reInit(int x,int y)
  39.   {
  40.     this.x = x;
  41.     this.y = y;
  42.     isHidden = true;
  43.   }
  44.   public void createGem(MarioGameManage gm)
  45.   {
  46.     if(isHidden)
  47.     {
  48.       isHidden=false;
  49.       gm.createGold(x,y);
  50.       if(++gm.goldNum==100)
  51.       {
  52.         gm.goldNum = 0;
  53.       }
  54.       if(gm.menu.isVolOn)
  55.       {
  56.         gm.beatPlayer.replay();
  57.       }
  58.       frameCnt=0;
  59.     }
  60.   }
  61. }
  62. class MarioGemHidden extends MarioBrick
  63. {
  64.   public MarioGemHidden(int x,int y)
  65.   {
  66.     super(x,y);
  67.     isHidden =true;
  68.   }
  69.   public void reInit(int x,int y)
  70.   {
  71.     this.x=x;
  72.     this.y=y;
  73.     isHidden =true;
  74.   }
  75.   public void createGem(MarioGameManage gm)
  76.   {
  77.     if(isHidden)
  78.     {
  79.       isHidden=false;
  80.       gm.createGem(x,y);
  81.       frameCnt=0;
  82.     }
  83.   }
  84. }
  85. class MarioBrickGemHidden extends MarioBrick
  86. {
  87.   private boolean hasUsed = false;
  88.   public MarioBrickGemHidden(int x,int y)
  89.   {
  90.     super(x,y);
  91.     isHidden = true;
  92.   }
  93.   public void reInit(int x,int y)
  94.   {
  95.     this.x = x;
  96.     this.y = y;
  97.     isHidden = true;
  98.   }
  99.   public void createGem(MarioGameManage gm)
  100.   {
  101.     if(isHidden)
  102.     {
  103.       if(!hasUsed)
  104.       {
  105.         isHidden=false;
  106.         gm.createGemPeople(x,y);
  107.         hasUsed = true;
  108.         frameCnt=0;
  109.       }
  110.     }
  111.   }
  112. }
  113. class MarioBrickGemQuestion extends MarioBrick
  114. {
  115.   public MarioBrickGemQuestion(int x,int y)
  116.   {
  117.     super(x,y);
  118.     this.frameCnt = 3;
  119.   }
  120.   public void action()
  121.   {
  122.     if (frameCnt != 0)
  123.     {
  124.       if (++timeCnt % 3 == 0)
  125.       {
  126.         frameCnt = 5 - frameCnt;
  127.       }
  128.     }
  129.   }
  130.   public void reInit(int x,int y)
  131.   {
  132.     super.reInit(x,y);
  133.     frameCnt = 3;
  134.   }
  135.   public void createGem(MarioGameManage gm)
  136.   {
  137.     if(frameCnt!=0)
  138.     {
  139.       gm.createGem(x,y);
  140.       frameCnt = 0;
  141.     }
  142.   }
  143. }
  144. class MarioBrickGem extends MarioBrick
  145. {
  146.   public MarioBrickGem(int x,int y)
  147.   {
  148.     super(x,y);
  149.     this.frameCnt = 1;
  150.   }
  151.   public void reInit(int x,int y)
  152.   {
  153.     super.reInit(x,y);
  154.     frameCnt = 1;
  155.   }
  156.   public void createGem(MarioGameManage gm)
  157.   {
  158.     if(frameCnt!=0)
  159.     {
  160.       gm.createGem(x,y);
  161.       frameCnt=0;
  162.     }
  163.   }
  164. }
  165. class MarioBrickGold extends MarioBrick
  166. {
  167.   protected boolean beginCount;
  168.   public MarioBrickGold(int x,int y)
  169.   {
  170.     super(x,y);
  171.     this.frameCnt = 1;
  172.     beginCount = false;
  173.   }
  174.   public void action()
  175.   {
  176.     if (frameCnt != 0)
  177.     {
  178.       if (beginCount)
  179.       {
  180.         ++timeCnt;
  181.       }
  182.     }
  183.   }
  184.   public void reInit(int x,int y)
  185.   {
  186.     this.x = x;
  187.     this.y = y;
  188.     beginCount = false;
  189.     frameCnt = 1;
  190.     timeCnt = 0;
  191.   }
  192.   public void createGem(MarioGameManage gm)
  193.   {
  194.     if(frameCnt!=0)
  195.     {
  196.       beginCount = true;
  197.       gm.createGold(x,y);
  198.       if(++gm.goldNum==100)
  199.       {
  200.         gm.goldNum=0;
  201.       }
  202.       if(gm.menu.isVolOn)
  203.       {
  204.         gm.beatPlayer.replay();
  205.       }
  206.       if(timeCnt >= 60)
  207.       {
  208.         frameCnt = 0;
  209.       }
  210.     }
  211.   }
  212.   public void writeData(DataOutputStream dos) throws IOException
  213.   {
  214.     super.writeData(dos);
  215.     dos.writeBoolean(beginCount);
  216.   }
  217.   public void readData(DataInputStream dis) throws IOException
  218.   {
  219.     super.readData(dis);
  220.     beginCount = dis.readBoolean();
  221.   }
  222. }
  223. class MarioBrickGoldQuestion extends MarioBrick
  224. {
  225.   public MarioBrickGoldQuestion(int x,int y)
  226.   {
  227.     super(x,y);
  228.     frameCnt = 3;
  229.   }
  230.   public void reInit(int x,int y)
  231.   {
  232.     super.reInit(x,y);
  233.     frameCnt = 3;
  234.   }
  235.   public void action()
  236.   {
  237.     if (frameCnt != 0)
  238.     {
  239.       if (++timeCnt % 3 == 0)
  240.       {
  241.         frameCnt = 5 - frameCnt;
  242.       }
  243.     }
  244.   }
  245.   public void createGem(MarioGameManage gm)
  246.   {
  247.     if(frameCnt!=0)
  248.     {
  249.       gm.createGold(x,y);
  250.       frameCnt = 0;
  251.       if(++gm.goldNum==100)
  252.       {
  253.         gm.goldNum=0;
  254.       }
  255.       if(gm.menu.isVolOn)
  256.       {
  257.         gm.beatPlayer.replay();
  258.       }
  259.     }
  260.   }
  261. }
  262. class Mashroom extends LPSprite
  263. {
  264.   private int growCnt;
  265.   private MarioGameManage gm;
  266.   private int dy;
  267.   private LPRect rect1 = new LPRect();
  268.   private LPRect rect2 = new LPRect();
  269.   private int xSpeed;
  270.   public void writeData(DataOutputStream dos) throws IOException
  271.   {
  272.     super.writeData(dos);
  273.     dos.writeInt(growCnt);
  274.     dos.writeInt(dy);
  275.     dos.writeInt(xSpeed);
  276.   }
  277.   public void readData(DataInputStream dis) throws IOException
  278.   {
  279.     super.readData(dis);
  280.     growCnt = dis.readInt();
  281.     dy = dis.readInt();
  282.     xSpeed = dis.readInt();
  283.   }
  284.   public Mashroom(MarioGameManage gm)
  285.   {
  286.     isHidden = true;
  287.     frameCnt = 6;
  288.     this.gm = gm;
  289.     rect1.dx = 16;
  290.     rect1.dy = 16;
  291.     rect2.dx = 16;
  292.     rect2.dy = 16;
  293.   }
  294.   public void changeDirection()
  295.   {
  296.     dy-=5;
  297.     xSpeed = -xSpeed;
  298.   }
  299.   private boolean checkTileCollisionHorn()
  300.   {
  301.     int i;
  302.     rect1.y = this.y + gm.mainSprite.judgeMap.y;
  303.     if (xSpeed<0)
  304.     {
  305.       rect1.x = x + gm.mainSprite.judgeMap.x - 4;
  306.       i = (x + gm.mainSprite.judgeMap.x - 4) / gm.mainSprite.judgeMap.tileSize;
  307.     }
  308.     else
  309.     {
  310.       rect1.x = x + gm.mainSprite.judgeMap.x + 4;
  311.       i = (x + gm.mainSprite.judgeMap.x + 4) / gm.mainSprite.judgeMap.tileSize + 1;
  312.     }
  313.     if (i < 0 || i > gm.mainSprite.judgeMap.w - 1)
  314.       return false;
  315.     int yTile1 = (y + gm.mainSprite.judgeMap.y) / gm.mainSprite.judgeMap.tileSize;
  316.     int yTile2 = (y + gm.mainSprite.judgeMap.y) / gm.mainSprite.judgeMap.tileSize + 1;
  317.     if (yTile1 < 0 || yTile2 > gm.mainSprite.judgeMap.h - 1)
  318.       return false;
  319.     if ( ( (gm.mainSprite.judgeMap.mapArray[yTile1][i] >> 8) & 0x04) == 0x04)
  320.     {
  321.       rect2.x = i * 16;
  322.       rect2.y = yTile1 * 16;
  323.       if (LPRect.IntersectRect(rect1, rect2))
  324.       {
  325.         return true;
  326.       }
  327.     }
  328.     if ( ( (gm.mainSprite.judgeMap.mapArray[yTile2][i] >> 8) & 0x04) == 0x04)
  329.     {
  330.       rect2.x = i * 16;
  331.       rect2.y = yTile2 * 16;
  332.       if (LPRect.IntersectRect(rect1, rect2))
  333.       {
  334.         return true;
  335.       }
  336.     }
  337.     return false;
  338.   }
  339.   private void checkTileCollisionVert()
  340.   {
  341.     if (this.dy >= 0)
  342.     {
  343.       for (int i = (y + gm.mainSprite.judgeMap.y) /
  344.            gm.mainSprite.judgeMap.tileSize + 1;
  345.            i <=
  346.            (y + gm.mainSprite.judgeMap.y + dy) / gm.mainSprite.judgeMap.tileSize +
  347.            1; i++)
  348.       {
  349.         if (i < 0 || i > gm.mainSprite.judgeMap.h - 1)
  350.         {
  351.           continue;
  352.         }
  353.         int xTile1 = (x + gm.mainSprite.judgeMap.x + 2) /
  354.           gm.mainSprite.judgeMap.tileSize;
  355.         int xTile2 = (x + gm.mainSprite.judgeMap.x + 14) /
  356.           gm.mainSprite.judgeMap.tileSize;
  357.         if (xTile2 > gm.mainSprite.judgeMap.w - 1 || xTile1 < 0)
  358.         {
  359.           return;
  360.         }
  361.         if ( ( (gm.mainSprite.judgeMap.mapArray[i][xTile1] >> 8) & 0x02) ==
  362.             0x02)
  363.         {
  364.           dy = (i - 1) * gm.mainSprite.judgeMap.tileSize -
  365.             (y + gm.mainSprite.judgeMap.y);
  366.           return;
  367.         }
  368.         if ( ( (gm.mainSprite.judgeMap.mapArray[i][xTile2] >> 8) & 0x02) ==
  369.             0x02)
  370.         {
  371.           dy = (i - 1) * gm.mainSprite.judgeMap.tileSize -
  372.             (y + gm.mainSprite.judgeMap.y);
  373.           return;
  374.         }
  375.       }
  376.     }
  377.   }
  378.   private void checkSpriteCollisionVert()
  379.   {
  380.     if (dy >= 0)
  381.     {
  382.       int i;
  383.       for (i = gm.brick.length - 1; i >= 0; --i)
  384.       {
  385.         if (!gm.brick[i].isHidden)
  386.         {
  387.           if ( ( (y + 16) <= gm.brick[i].y) &&
  388.               ( (y + dy + 16) >= gm.brick[i].y)
  389.               && (x >= gm.brick[i].x - 10) && (x <= gm.brick[i].x + 12))
  390.           {
  391.             dy = gm.brick[i].y - (y + 16);
  392.             return;
  393.           }
  394.         }
  395.       }
  396.     }
  397.   }
  398.   public void draw(Graphics g, LPImageManage im)
  399.   {
  400.     if (!isHidden)
  401.     {
  402.       if (growCnt < im.frameSize)
  403.       {
  404.         g.setClip(x,
  405.                   y, im.frameSize,
  406.                   growCnt);
  407.       }
  408.       else
  409.       {
  410.         g.setClip(x, y, im.frameSize, im.frameSize);
  411.       }
  412.       g.drawImage(im.image, x,
  413.                   y -
  414.                   frameCnt *
  415.                   im.frameSize, g.LEFT | g.TOP);
  416.       g.setClip(0, 0, MarioMIDlet.gameCanvas.width,
  417.                 MarioMIDlet.gameCanvas.height);
  418.     }
  419.   }
  420.   public void action()
  421.   {
  422.     if(!isHidden)
  423.     {
  424.       if(growCnt<16)
  425.       {
  426.         y-=2;
  427.         growCnt+=2;
  428.       }
  429.       else
  430.       {
  431.         if(x<-100||x>gm.canvas.width+100
  432.            || y>gm.canvas.height+50)
  433.         {
  434.           isHidden = true;
  435.           return;
  436.         }
  437.         ++dy;
  438.         checkTileCollisionVert();
  439.         checkSpriteCollisionVert();
  440.         y += dy;
  441.         if (!checkTileCollisionHorn())
  442.         {
  443.           x += xSpeed;
  444.         }
  445.         else
  446.         {
  447.           xSpeed = -xSpeed;
  448.         }
  449.       }
  450.     }
  451.   }
  452.   public void reInit(int x,int y)
  453.   {
  454.     isHidden = false;
  455.     this.x = x;
  456.     this.y = y;
  457.     growCnt = 0;
  458.     xSpeed = 4;
  459.   }
  460. }
  461. class MashroomPeople extends Mashroom
  462. {
  463.   public MashroomPeople(MarioGameManage gm)
  464.   {
  465.     super(gm);
  466.     frameCnt = 8;
  467.   }
  468. }
  469. class Flower
  470.   extends LPSprite
  471. {
  472.   private int growCnt;
  473.   public void writeData(DataOutputStream dos) throws IOException
  474.   {
  475.     super.writeData(dos);
  476.     dos.writeInt(growCnt);
  477.   }
  478.   public void readData(DataInputStream dis) throws IOException
  479.   {
  480.     super.readData(dis);
  481.     growCnt = dis.readInt();
  482.   }
  483.   public Flower()
  484.   {
  485.     isHidden = true;
  486.     frameCnt = 7;
  487.   }
  488.   public void draw(Graphics g, LPImageManage im)
  489.   {
  490.     if (!isHidden)
  491.     {
  492.       if (growCnt < im.frameSize)
  493.       {
  494.         g.setClip(x,
  495.                   y, im.frameSize,
  496.                   growCnt);
  497.       }
  498.       else
  499.       {
  500.         g.setClip(x, y, im.frameSize, im.frameSize);
  501.       }
  502.       g.drawImage(im.image, x,
  503.                   y -
  504.                   frameCnt *
  505.                   im.frameSize, g.LEFT | g.TOP);
  506.       g.setClip(0, 0, MarioMIDlet.gameCanvas.width,
  507.                 MarioMIDlet.gameCanvas.height);
  508.     }
  509.   }
  510.   public void action()
  511.   {
  512.     if (!isHidden)
  513.     {
  514.       if (growCnt < 16)
  515.       {
  516.         y -= 2;
  517.         growCnt += 2;
  518.       }
  519.     }
  520.   }
  521.   public void reInit(int x, int y)
  522.   {
  523.     isHidden = false;
  524.     this.x = x;
  525.     this.y = y;
  526.     growCnt = 0;
  527.   }
  528. }
  529. class StaticGold extends LPSprite
  530. {
  531.   public StaticGold(int x,int y)
  532.   {
  533.     this.x = x;
  534.     this.y = y;
  535.     this.frameCnt = 4;
  536.   }
  537.   public void action()
  538.   {
  539.     if(++timeCnt%4==0)
  540.     {
  541.       frameCnt=9-frameCnt;
  542.     }
  543.   }
  544. }
  545. class Gold extends LPSprite
  546. {
  547.   private int dy;
  548.   public void writeData(DataOutputStream dos) throws IOException
  549.   {
  550.     super.writeData(dos);
  551.     dos.writeInt(dy);
  552.   }
  553.   public void readData(DataInputStream dis) throws IOException
  554.   {
  555.     super.readData(dis);
  556.     dy = dis.readInt();
  557.   }
  558.   public Gold()
  559.   {
  560.     isHidden = true;
  561.     frameCnt = 4;
  562.   }
  563.   public void action()
  564.   {
  565.     if(dy <5)
  566.     {
  567.       dy+=2;
  568.       y+=dy;
  569.       if(dy>=5)
  570.       {
  571.         isHidden=true;
  572.       }
  573.     }
  574.   }
  575.   public void reInit(int x,int y)
  576.   {
  577.     this.x = x;
  578.     this.y = y;
  579.     this.isHidden = false;
  580.     dy = -12;
  581.   }
  582. }