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

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 lipeng.LPRect;
  15. import java.io.DataInputStream;
  16. import java.io.DataOutputStream;
  17. import java.io.IOException;
  18. public class MarioEnemySprite
  19.   extends LPSprite
  20. {
  21.   protected MarioGameManage gm;
  22.   protected int dy;
  23.   protected static LPRect rect1=new LPRect();
  24.   protected static LPRect rect2=new LPRect();
  25.   protected int xSpeed;
  26.   public int state;
  27.   public boolean isCheck;
  28.   public void writeData(DataOutputStream dos) throws IOException
  29.   {
  30.     super.writeData(dos);
  31.     dos.writeInt(dy);
  32.     dos.writeInt(xSpeed);
  33.     dos.writeInt(state);
  34.     dos.writeBoolean(isCheck);
  35.   }
  36.   public void readData(DataInputStream dis) throws IOException
  37.   {
  38.     super.readData(dis);
  39.     dy = dis.readInt();
  40.     xSpeed = dis.readInt();
  41.     state = dis.readInt();
  42.     isCheck = dis.readBoolean();
  43.   }
  44.   public MarioEnemySprite(MarioGameManage gm)
  45.   {
  46.     this.gm=gm;
  47.     isCheck = true;
  48.     rect1.dx = 16;
  49.     rect1.dy = 16;
  50.     rect2.dx = 16;
  51.     rect2.dy = 16;
  52.   }
  53.   protected boolean checkTileCollisionHorn()
  54.   {
  55.     int i;
  56.     rect1.y=y+gm.mainSprite.judgeMap.y;
  57.     rect1.x=x+gm.mainSprite.judgeMap.x+xSpeed;
  58.     if(xSpeed<0)
  59.     {
  60.       i=(x+gm.mainSprite.judgeMap.x+xSpeed)/gm.mainSprite.judgeMap.tileSize;
  61.     }
  62.     else
  63.     {
  64.       i=(x+gm.mainSprite.judgeMap.x+xSpeed)/gm.mainSprite.judgeMap.tileSize+1;
  65.     }
  66.     if(i<0||i>gm.mainSprite.judgeMap.w-1)
  67.       return false;
  68.     int yTile1=(y+gm.mainSprite.judgeMap.y)/gm.mainSprite.judgeMap.tileSize;
  69.     int yTile2=(y+gm.mainSprite.judgeMap.y)/gm.mainSprite.judgeMap.tileSize+1;
  70.     if(yTile1<0||yTile2>gm.mainSprite.judgeMap.h-1)
  71.       return false;
  72.     if(((gm.mainSprite.judgeMap.mapArray[yTile1][i]>>8)&0x04)==0x04)
  73.     {
  74.       rect2.x=i*16;
  75.       rect2.y=yTile1*16;
  76.       if(LPRect.IntersectRect(rect1,rect2))
  77.       {
  78.         return true;
  79.       }
  80.     }
  81.     if(((gm.mainSprite.judgeMap.mapArray[yTile2][i]>>8)&0x04)==0x04)
  82.     {
  83.       rect2.x=i*16;
  84.       rect2.y=yTile2*16;
  85.       if(LPRect.IntersectRect(rect1,rect2))
  86.       {
  87.         return true;
  88.       }
  89.     }
  90.     return false;
  91.   }
  92.   protected boolean checkTileCollisionVert()
  93.   {
  94.     if(this.dy>=0)
  95.     {
  96.       for(int i=(y+gm.mainSprite.judgeMap.y)/
  97.           gm.mainSprite.judgeMap.tileSize+1;
  98.           i<=
  99.           (y+gm.mainSprite.judgeMap.y+dy)/gm.mainSprite.judgeMap.tileSize+
  100.           1;i++)
  101.       {
  102.         if(i<0||i>gm.mainSprite.judgeMap.h-1)
  103.         {
  104.           continue;
  105.         }
  106.         int xTile1=(x+gm.mainSprite.judgeMap.x+2)/
  107.           gm.mainSprite.judgeMap.tileSize;
  108.         int xTile2=(x+gm.mainSprite.judgeMap.x+14)/
  109.           gm.mainSprite.judgeMap.tileSize;
  110.         if(xTile2>gm.mainSprite.judgeMap.w-1||xTile1<0)
  111.         {
  112.           return false;
  113.         }
  114.         if(((gm.mainSprite.judgeMap.mapArray[i][xTile1]>>8)&0x02)==
  115.            0x02)
  116.         {
  117.           dy=(i-1)*gm.mainSprite.judgeMap.tileSize-
  118.             (y+gm.mainSprite.judgeMap.y);
  119.           return true;
  120.         }
  121.         if(((gm.mainSprite.judgeMap.mapArray[i][xTile2]>>8)&0x02)==
  122.            0x02)
  123.         {
  124.           dy=(i-1)*gm.mainSprite.judgeMap.tileSize-
  125.             (y+gm.mainSprite.judgeMap.y);
  126.           return true;
  127.         }
  128.       }
  129.     }
  130.     return false;
  131.   }
  132.   protected boolean checkSpriteCollisionVert()
  133.   {
  134.     if(dy>=0)
  135.     {
  136.       int i;
  137.       for(i=gm.brick.length-1;i>=0;--i)
  138.       {
  139.         if(!gm.brick[i].isHidden)
  140.         {
  141.           if(((y+16)<=gm.brick[i].y)&&
  142.              ((y+dy+16)>=gm.brick[i].y)
  143.              &&(x>=gm.brick[i].x-10)&&(x<=gm.brick[i].x+12))
  144.           {
  145.             dy=gm.brick[i].y-(y+16);
  146.             return true;
  147.           }
  148.         }
  149.       }
  150.       for(i=gm.bridge.length-1;i>=0;--i)
  151.       {
  152.         if(!gm.bridge[i].isHidden)
  153.         {
  154.           if(((y+16)<=gm.bridge[i].y)&&
  155.              ((y+dy+16)>=gm.bridge[i].y)
  156.              &&(x>=gm.bridge[i].x-10)&&(x<=gm.bridge[i].x+12))
  157.           {
  158.             dy=gm.bridge[i].y-(y+16);
  159.             return true;
  160.           }
  161.         }
  162.       }
  163.     }
  164.     return false;
  165.   }
  166.   protected boolean checkSpriteCollisionHorn()
  167.   {
  168.     return false;
  169.   }
  170.   public void changeDirection()
  171.   {
  172.   }
  173.   public void changeState()
  174.   {
  175.   }
  176. }
  177. class EnemyTortoise extends MarioEnemySprite
  178. {
  179.   public boolean isPushable;
  180.   protected int originX;
  181.   protected int originY;
  182.   protected boolean isLeft;
  183.   protected int interval;
  184.   public void writeData(DataOutputStream dos) throws IOException
  185.   {
  186.     super.writeData(dos);
  187.     dos.writeInt(originX);
  188.     dos.writeInt(originY);
  189.     dos.writeBoolean(isLeft);
  190.     dos.writeInt(interval);
  191.   }
  192.   public void readData(DataInputStream dis) throws IOException
  193.   {
  194.     super.readData(dis);
  195.     originX = dis.readInt();
  196.     originY = dis.readInt();
  197.     isLeft = dis.readBoolean();
  198.     interval = dis.readInt();
  199.   }
  200.   public EnemyTortoise(int x,int y,MarioGameManage gm)
  201.   {
  202.     super(gm);
  203.     this.x = x;
  204.     this.y = y;
  205.     state = 0;
  206.     xSpeed = -2;
  207.     isPushable = false;
  208.     isCheck = true;
  209.     originX = x;
  210.     originY = y;
  211.   }
  212.   public void action()
  213.   {
  214.     if(!isHidden)
  215.     {
  216.       if(state==0)
  217.       {
  218.         if(x>gm.canvas.width+50||x<-50
  219.            ||y<0||y>gm.canvas.height+30)
  220.         {
  221.           return;
  222.         }
  223.         ++dy;
  224.         y+=8;
  225.         checkSpriteCollisionVert();
  226.         checkTileCollisionVert();
  227.         y+=dy;
  228.         if(!checkTileCollisionHorn())
  229.         {
  230.           x+=xSpeed;
  231.         }
  232.         else
  233.         {
  234.           xSpeed=-xSpeed;
  235.         }
  236.         y-=8;
  237.         ++frameCnt;
  238.         if(frameCnt>1+offset||frameCnt<0+offset)
  239.         {
  240.           frameCnt=0+offset;
  241.         }
  242.         if(xSpeed>0)
  243.         {
  244.           offset=0;
  245.         }
  246.         else
  247.         {
  248.           offset=2;
  249.         }
  250.       }
  251.       else if(state==1)
  252.       {
  253.         ++dy;
  254.         y+=8;
  255.         checkSpriteCollisionVert();
  256.         checkTileCollisionVert();
  257.         y+=dy;
  258.         y-=8;
  259.         if(++timeCnt==200)
  260.         {
  261.           state=0;
  262.           frameCnt=0;
  263.           timeCnt=0;
  264.           isPushable = false;
  265.           isCheck = true;
  266.         }
  267.       }
  268.       else if(state==2)
  269.       {
  270.         ++dy;
  271.         y+=8;
  272.         checkSpriteCollisionVert();
  273.         checkTileCollisionVert();
  274.         y+=dy;
  275.         if(!checkTileCollisionHorn())
  276.         {
  277.           x+=xSpeed;
  278.         }
  279.         else
  280.         {
  281.           xSpeed=-xSpeed;
  282.         }
  283.         y-=8;
  284.       }
  285.       else if(state==3)
  286.       {
  287.         ++dy;
  288.         y+=dy;
  289.         if(y>gm.canvas.height)
  290.         {
  291.           isHidden = true;
  292.         }
  293.       }
  294.     }
  295.   }
  296.   public void reInit(int x,int y)
  297.   {
  298.     super.reInit(x,y);
  299.     state = 0;
  300.     xSpeed = -2;
  301.     isPushable = false;
  302.     isCheck = true;
  303.   }
  304.   public void changeState()
  305.   {
  306.     if(state==0)
  307.     {
  308.       state = 1;
  309.       frameCnt = 4;
  310.       isPushable = true;
  311.       isCheck = false;
  312.     }
  313.     else if(state==1)
  314.     {
  315.       state = 2;
  316.       isPushable = false;
  317.       isCheck = true;
  318.       if(gm.mainSprite.x<x)
  319.       {
  320.         xSpeed = 10;
  321.       }
  322.       else
  323.       {
  324.         xSpeed = -10;
  325.       }
  326.       x+=xSpeed;
  327.     }
  328.     else if(state==2)
  329.     {
  330.       state=1;
  331.       frameCnt=4;
  332.       isPushable=true;
  333.       xSpeed = 2;
  334.       isCheck = false;
  335.     }
  336.   }
  337.   public void changeDirection()
  338.   {
  339.     frameCnt = 5;
  340.     state = 3;
  341.     isCheck = false;
  342.   }
  343. }
  344. class EnemyTortoiseHorn extends EnemyTortoise
  345. {
  346.   public EnemyTortoiseHorn(int x,int y,int interval,MarioGameManage gm)
  347.   {
  348.     super(x,y,gm);
  349.     state = 0;
  350.     this.interval = interval;
  351.   }
  352.   public void reInit(int x,int y)
  353.   {
  354.     super.reInit(x,y);
  355.     state = 0;
  356.   }
  357.   public void action()
  358.   {
  359.     if(!isHidden)
  360.     {
  361.       if(state==0)
  362.       {
  363.         if(isLeft)
  364.         {
  365.           x-=2;
  366.           if(originX-(gm.mainSprite.judgeMap.x+x)>interval)
  367.           {
  368.             isLeft=false;
  369.             offset=0;
  370.           }
  371.         }
  372.         else
  373.         {
  374.           x+=2;
  375.           if((x+gm.mainSprite.judgeMap.x)-originX>interval)
  376.           {
  377.             isLeft=true;
  378.             offset=2;
  379.           }
  380.         }
  381.         ++frameCnt;
  382.         if(frameCnt>1+offset||frameCnt<0+offset)
  383.         {
  384.           frameCnt=0+offset;
  385.         }
  386.       }
  387.       else
  388.       {
  389.         super.action();
  390.       }
  391.     }
  392.   }
  393. }