写个简单的飞机游戏玩玩

用c++做一个简单的打飞机小游戏(详细说明与注释) #include <bits/stdc++.h> #include <windows.h> #define KEY_DOWN(VK_NONAME) ((GetAsyncKeyState(VK_NONAME) & 0x8000) ? 1:0) #define N 10005 using namespace std; struct plane { int pos_x,pos_y,size,vis; }plane[N+5],player; struct bullet { int 阅读详情

写个简单的飞机游戏玩玩

 

侯亮

 

 

1      概述

        前些天看了《Android游戏编程之从零开始》一书中一个简单飞机游戏的实现代码,一时手痒,也写了一个练练手。虽然我的本职工作并不是写游戏,不过程序员或多或少都有编写游戏的情结,那就写吧,Just for fun!游戏的代码部分我基本上全部重写了,至于游戏的图片资源嘛,我老实不客气地全拿来复用了一下,呵呵,希望李华明先生不要见怪啊。

 

        在Android平台上,SurfaceView就足以应付所有简单游戏了。当然我说的是简单游戏,如果要写复杂游戏,恐怕还得使用各种游戏引擎,不过游戏引擎不是本文关心的重点,对于我写的简单游戏来说,用SurfaceView就可以了。

 

        飞机游戏的一个小特点是,画面总是在变动的,这当然是句废话,不过却能引出一个关键的设计核心,那就是“帧流”。帧流的最典型例子大概就是电影啦,我们知道,只要胶片按每秒钟24帧(或者更高)的速率播放,人眼就会误以为看到了连续的运动画面。飞机游戏中的运动画面大体也是这样呈现的,因此游戏设计者必须设计出一条平滑的帧流,并且帧率要足够快。

 

        从技术上说,我们可以在一个线程中,构造一个不断绘制“帧”的while循环,并在每次画好帧后,调用Thread.sleep()睡眠合适的时间,这样就可以实现一个相对平滑的帧流了。

 

        另一方面,游戏的逻辑也是可以融入到帧流里的,也就是说,每次画好帧后,我们可以调用一个类似execLogic()的函数来执行游戏逻辑,从而(间接)产生新的帧。而游戏逻辑又可以划分成多个子逻辑,比如关卡背景逻辑、敌人行为逻辑、玩家飞机逻辑、子弹行为逻辑、碰撞逻辑等等,这个我们后文再细说。

 

        大概说起来就是这么多了,现在我们逐个来看游戏设计中的细节。

 

2      平滑的帧流

        我们先写个全屏显示的Activity:

public class HLPlaneGameActivity extends Activity
{
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        this.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                                 WindowManager.LayoutParams.FLAG_FULLSCREEN);
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        setContentView(new PlaneGameView(this));
    }
}

这个Activity的主视图是PlaneGameView类,它继承于SurfaceView。

public class PlaneGameView extends SurfaceView implements Callback, Runnable

 

         一旦surface创建成功,我们就启动一个线程,这个线程负责运作帧流。

@Override
public void surfaceCreated(SurfaceHolder holder)
{
    GlobalInfo.screenW = getWidth();
    GlobalInfo.screenH = getHeight();
    mSurfaceWorking = true;
   
    mGameManager = new GameManager(getContext());
   
    mGameThread = new Thread(this);
    mGameThread.start();
}

         mGameThread线程的核心run()函数的代码如下:

@Override
public void run()
{
    while (mSurfaceWorking)
    {
        long start = System.currentTimeMillis();
       
        drawFrame();    // 画帧!
        execLogic();    // 执行所有游戏逻辑!
       
        long end = System.currentTimeMillis();
        try
        {
            if (end - start < 50)
            {
                Thread.sleep(50 - (end - start));    // 睡眠合适的时间!
            }
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}

画帧、游戏逻辑、合适的sleep,一气呵成。为了便于计算,此处我采用了每秒20帧的帧率,所以每帧平均50毫秒,而且因为画帧和执行游戏逻辑都是需要消耗时间的,所以合适的sleep()动作应该写成:Thread.sleep(50 - (end - start))。

 

3      GameManager

3.1  整合游戏中所有元素

        为了便于管理,我设计了一个GameManager管理类。这个类到底是干什么的呢?简单地说,它整合了游戏中的所有元素,目前有:

  • 绘制关卡背景;
  • 所有敌人;
  • 爆炸特效;
  • 所有子弹、炮弹;
  • 玩家(player)飞机;
  • 游戏信息面板;

当然,以后还可以再扩展一些东西,它们的机理是接近的。

 

        GameManager的代码截选如下:

public class GameManager
{
    private Context mContext = null;
   
    private GameStage       mCurStage   = null;
    private Player          mPlayer     = null;
    private EnemyManager    mEnemyMgr   = null;
    private BulletsManager  mPlayerBulletsMgr = new BulletsManager();
    private BulletsManager  mEnemyBulletsMgr  = new BulletsManager();
    private ExplodeManager mExplodeMgr        = null;
    private GameInfoPanel   mGameInfoPanel     = null;
 

        GameManager的总模块关系示意图如下:


 

既然在“帧流”线程里最重要的动作是drawFrame()和execLogic(),那么GameManager类也必须提供这两个成员函数,这样帧流线程只需直接调用GameManager的同名函数即可。

 

3.2  GameManager的画帧动作

        帧流线程的drawFrame()函数,其代码如下:

public void drawFrame()
{
    Canvas canvas = null;
   
    try
    {
        canvas = mSfcHolder.lockCanvas();
        if (canvas == null)
        {
            return;
        }
        mGameManager.drawFrame(canvas);
    }
    catch (Exception e)
    {
        // TODO: handle exception
    }
    finally
    {
        if (canvas != null)
        {
            mSfcHolder.unlockCanvasAndPost(canvas);
        }
    }
}

其中GameManager的drawFrame()函数如下:

public void drawFrame(Canvas canvas)
{
    mCurStage.drawFrame(canvas);
    mEnemyMgr.drawFrame(canvas);
    mExplodeMgr.drawFrame(canvas);
    mPlayerBulletsMgr.drawFrame(canvas);
    mEnemyBulletsMgr.drawFrame(canvas);
    mPlayer.drawFrame(canvas);
    mGameInfoPanel.drawFrame(canvas);
}

无非是调用所有游戏角色的drawFrame()而已。

 

         每个游戏角色有自己的存活期,在其存活期中,可以通过drawFrame()向canvas中的合适位置绘制相应的图片。示意图如下:


在上面的示意图中,两个enemy的生存期都只有5帧,当帧流绘制到上图的紫色帧时,会先绘制enemy_1的第1帧,而后绘制enemy_2的第5帧,最后绘制player的当前帧。(当然,这里我们只是简单阐述原理,大家如有兴趣,可以再在这张图上添加其他的游戏元素。)绘制完毕后的最终效果,就是屏幕展示给用户的最终画面。

 

         每个游戏角色都非常清楚自己当前应该如何绘制,而且它通过执行自己的子逻辑,决定出下一帧该如何绘制,这就是游戏中最重要的画帧流程。

 

3.3  GameManager管理所有的子逻辑

        其实,游戏的整体运作是由两个方面带动的,一个是“软件内部控制”,主要控制所有“非player角色”的移动和动作,比如每个enemy下一步移动到哪里,如何发射子弹等等;另一个是“用户操作”,主要控制“player角色”的移动和动作(这部分我们放在后文再说)。在前文所说的帧流线程里,是通过调用GameManager的execLogic()来完成所有“软件内部控制”的,其代码如下:

public void execLogic()
{
    mCurStage.execLogic();
    mEnemyMgr.execLogic();
    mPlayer.execLogic();
    mPlayerBulletsMgr.execLogic();
    mEnemyBulletsMgr.execLogic();
    mExplodeMgr.execLogic();
    mGameInfoPanel.execLogic();
    execCollsionLogic();       // 碰撞逻辑
}

         从上面代码就可以看出,GameManager所管理的子逻辑大概有以下几个:

  • 关卡运作子逻辑
  • 所有敌人的运作子逻辑
  • 玩家角色的子逻辑
  • 玩家发射的子弹的子逻辑
  • 敌人发射的子弹的子逻辑
  • 管理爆炸效果的子逻辑
  • 游戏信息面板的子逻辑
  • 碰撞子逻辑

 

4      游戏子逻辑

4.1  关卡运作子逻辑——GameStage

        我们先看前面execLogic()函数里的第一句:mCurState.execLogic(),这个mCurState是GameStage类型的,这个类主要维护当前关卡的相关数据。目前这个类非常简单,只维护了关卡背景图以及本关enemy的出现顺序表。

 

4.1.1   关卡背景图由StageBg类处理

一般来说,飞机游戏的背景是不断滚动的。为了实现滚动效果,我们可以绘制一张比屏幕长度更长的图片,并首尾相接地循环绘制它。

 

 

         在StageBg里,mBackGroundBmp1和mBackGroundBmp2这两个域其实指向的是同一个位图对象,之所以写成两个域,是为了代码更易于阅读。另外,mBgScrollSpeed用于表示背景滚动的速度,我们可以通过修改它,来体现飞行的速度。

 

4.1.2   关卡中的敌人的出场安排

GameStage的另一个重要职责是向游戏的主控制器(GameManager)提供一张表示敌人出场顺序的表,为此它提供了getEnemyMap()函数:

public int[][] getEnemyMap()
{
    // ENEMY_TYPE_NONE      = 0;
    // ENEMY_TYPE_DUCK      = 1;
    // ENEMY_TYPE_FLY       = 2;
    // ENEMY_TYPE_PIG       = 3;
    int[][] map = new int[][] {
            {0, 0, 0, 0, 1, 0, 0, 0, 0},
            {0, 0, 0, 1, 1, 1, 0, 0, 0},
            {0, 0, 0, 1, 0, 1, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 2, 1, 0, 0, 0, 1, 2, 0},
            {0, 2, 2, 1, 0, 1, 2, 2, 0},
            {0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 0, 1, 1},
            {0, 0, 0, 0, 0, 0, 1, 1, 1},
            {0, 2, 2, 0, 0, 0, 2, 2, 0},
            {0, 2, 2, 0, 0, 0, 2, 2, 0},
            {0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 3, 0, 0, 0, 0},
            };
   
    return map;
}

该函数返回的二维数组,表达的就是敌人的出场顺序和出场位置。我们目前是这样安排的,将屏幕均分为9列,每一列的特定位置对应二维数组中的一个整数,当数值为0时,表示此处没有敌人;当数值为1到3之间的整数时,分别代表此处将出现哪种敌人。现在我们只有3种敌人:DUCK,FLY,PIG。

  

          这一关卡只有一个BOSS,其类型为3型,对应上面的PIG。我们可以看到,它只会在上面出场表的最后一行出现一次。

 

4.2  EnemyManager

关卡里的所有敌人最好能统一管理,所以我编写了EnemyManager类。EnemyManager的定义截选如下:

public class EnemyManager implements IGameElement
{
    private ArrayList<Enemy> mEnemyList = new ArrayList<Enemy>();
    private int[][] mEnemyMap = null;
    private int mCurLine = 0;
    private int mEnemyCounter = 0;
    private Context mContext = null;
    private EnemyFactory   mEnemyFactory = null;
    private BulletsManager mBulletsMgr   = null;
    private ExplodeManager mExplodeMgr   = null;
    private Player mPlayer = null;
其中mEnemyList列表中会记录关卡里产生的所有敌人,当敌人被击毙之后,程序会把相应的Enemy对象从这张表中删除。mEnemyMap记录的其实就是前文所说的敌人的出场顺序表。另外,为了便于创建Enemy对象,我们可以先创建一个EnemyFactory对象,并记入mEnemyFactory域。

 

         另外,我们还需要管理所有Enemy发出的子弹,我们为EnemyManager添加了mBulletsMgr域,意思很简单,日后每个Enemy发射子弹时,其实都是向这个BulletsManager添加子弹对象。与此同理,我们还需要一个记录爆炸效果的爆炸管理器,那就是mExplodeMgr域。每当一个Enemy被击毙时,它会向爆炸管理器中添加一个爆炸效果对象。

 

4.2.1   drawFrame()

EnemyManager的绘制动作很简单,只需遍历一下所记录的Enemy列表,调用每个Enemy对象的drawFrame()函数即可。

@Override
public void drawFrame(Canvas canvas)
{
    Iterator<Enemy> itor = mEnemyList.iterator();
   
    while (itor.hasNext())
    {
        Enemy b = itor.next();
        b.drawFrame(canvas);
    }
}<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span>

4.2.2   execLogic()

        执行逻辑的动作也差不多,都需要遍历Enemy列表:

@Override
public void execLogic()
{
    execAddEnemyLogic();   // 添加enemy的地方!
   
    Iterator<Enemy> itor = mEnemyList.iterator();
    while (itor.hasNext())
    {
        Enemy b = itor.next();
        b.execLogic();  // 执行每个enemy的execLogic。
    }
   
    // EnemyManager还需要负责清理“已死亡”的enemy
    itor = mEnemyList.iterator();
    while (itor.hasNext())
    {
        Enemy b = itor.next();
        if (b.isDead())
        {
            itor.remove();  
        }
    }
}

         请注意,EnemyManager的execLogic()在一开始会调用execAddEnemyLogic()函数,因为我们总需要一个地方添加关卡里的enemy吧。

private void execAddEnemyLogic()
{
    mEnemyCounter++;
   
    if (mEnemyCounter % 24 == 0)
    {
        if (mCurLine < mEnemyMap.length)
        {
            for (int i = 0; i < mEnemyMap[mCurLine].length; i++)
            {
                addEnemy(mEnemyMap[mCurLine][i], i, mEnemyMap[mCurLine].length);
            }
        }
        mCurLine++;
    }
}

我们用一个mEnemyCounter计数器,来控制添加enemy的频率。帧流里每流动一帧,耗时大概50毫秒(因为我们设的帧率是20帧/秒),那么24帧大概会耗时24 * 50 = 1200毫秒。也就是说,每过1.2秒,我们就会向EnemyManager里添加一行enemy。至于这一行里具体有什么类型的enemy,是由mEnemyMap[ ]数组决定的。

 

         addEnemy的代码如下:

private void addEnemy(int enemyType, int colIdx, int colCount)
{
    Enemy enemy = null;
    int enemyCenterX, enemyCenterY;
   
    enemy = mEnemyFactory.createEnemy(enemyType);
    if (null == enemy)
    {
        return;
    }
   
    enemy.setBulletsManager(mBulletsMgr);
    enemy.setExplodeManager(mExplodeMgr);
    enemy.setTarget(mPlayer);
    mEnemyList.add(enemy);
   
    switch (enemyType)
    {
    case EnemyFactory.ENEMY_TYPE_DUCK:
    case EnemyFactory.ENEMY_TYPE_FLY:
        int colWidth = (int)((double)GlobalInfo.screenW / colCount);
        enemyCenterX = colWidth * colIdx + colWidth / 2;
        enemyCenterY = -1 * enemy.getHeight();
        enemy.setInitInfo(enemyCenterX, enemyCenterY, 8);
        break;
       
    case EnemyFactory.ENEMY_TYPE_PIG:
        enemyCenterX = GlobalInfo.screenW / 2;
        enemyCenterY = -1 * enemy.getHeight();
        enemy.setInitInfo(enemyCenterX, enemyCenterY, 8);
        break;
       
    default:
        break;
    }
}
代码很简单,先利用EnemyFactory根据不同的enemyType,创建相应的enemy对象。然后为每个enemy设置重要的关联对象,比如mBulletsMgr、mExplodeMgr、mPlayer。这是因为enemy总是要发子弹的嘛,那么它每发一颗子弹,都要向“子弹管理器”里添加子弹对象。同理,当enemy爆炸时,它也会向“爆炸管理器”里添加一个爆炸效果对象。又因为enemy常常需要瞄准玩家发射子弹,那么它就需要知道玩家的位置信息,因此setTarget(mPlayer)也是必要的。

 

        接着我们将enemy对象添加进EnemyManager的mEnemyList列表中。另外还需要为不同enemy设置不同的初始信息,比如初始位置、运行速度等等。

 

4.3  BulletsManager

        游戏中所有的子弹,不管是enemy发射的,还是玩家发射的,都必须添加进“子弹管理器”加以维护。只不过为了便于处理,我们把enemy和玩家发射的子弹分别放在了不同的BulletsManager里。这就是为什么在GameManager里,会有两个BulletsManager的原因:

private BulletsManager    mPlayerBulletsMgr = new BulletsManager();
private BulletsManager     mEnemyBulletsMgr  = new BulletsManager();


        BulletsManager的代码如下:

public class BulletsManager
{
    private ArrayList<Bullet> mBulletsList = new ArrayList<Bullet>();
   
    public void addBullet(Bullet bullet)
    {
        mBulletsList.add(bullet);
    }  
   
    public void drawFrame(Canvas canvas)
    {
        Iterator<Bullet> itor = mBulletsList.iterator();
       
        while (itor.hasNext())
        {
            Bullet b = itor.next();
            b.drawFrame(canvas);
        }
    }
   
    public void execLogic()
    {
        Iterator<Bullet> itor = mBulletsList.iterator();
       
        while (itor.hasNext())
        {
            Bullet b = itor.next();
            b.execLogic();
        }
       
        itor = mBulletsList.iterator();
        while (itor.hasNext())
        {
            Bullet b = itor.next();
            if (b.isDead())
            {
               itor.remove();
            }
        }
    }
   
    public ArrayList<Bullet> getBullets()
    {
        ArrayList<Bullet> bullets = (ArrayList<Bullet>)mBulletsList.clone();
        return bullets;
    }
}

从代码上看,它的drawFrame()和execLogic()和EnemyManager的同名函数很像。在execLogic()中,每当发现一颗子弹已经报废了,就会把它从mBulletsList列表里删除。嗯,用isDead()来表达子弹是否报废了好像不太贴切,不过大家应该都能够理解吧,呵呵。
 

         BulletsManager还得向外提供一个getBullets()函数,以便外界进行碰撞判断。这个我们在后文再细说。

 

4.4  ExplodeManager

        爆炸效果管理器和子弹管理器的逻辑代码差不多,所以我们就不贴它的execLogic()和drawFrame()的代码了。

 

         每个爆炸效果会对应一个Explode对象。因为爆炸效果一般都会表现为动画,所以Explode内部必须记录下自己当前该绘制哪一张图片了。在我们的程序里,爆炸资源图如下:


这张爆炸图会在Explode对象构造之时传入,而且外界会告诉Explode对象,爆炸图中总共有几帧。Explode的构造函数如下:

public Explode(int explodeType, Rect rect, Bitmap explodeBmp, int totalFrame)
{
    mType       = explodeType;
    mCurRect    = new Rect(rect);
    mExplodeBmp = explodeBmp;
    mTotalFrame = totalFrame;
 
    mFrameWidth  = mExplodeBmp.getWidth() / mTotalFrame;
    mFrameHeight = mExplodeBmp.getHeight();
}

         每当ExplodeManager遍历执行每个Explode对象的execLogic()时,会改变当前应该绘制的帧号。这样当游戏总帧流流动时,爆炸效果也就动起来了。Explode的execLogic()函数如下:

public void execLogic()
{
    mCurFrameIdx++;
    if (mCurFrameIdx >= mTotalFrame)
    {
        mState = STATE_DEAD;
    }
}

         具体绘制爆炸帧时,我们只需把爆炸图中与mCurFrameIdx对应的那一部分画出来就可以了,这就必须用到clipRect()。Explode的drawFrame()函数如下:

public void drawFrame(Canvas canvas)
{
    Rect srcRect = new Rect(mCurFrameIdx * mFrameWidth, 0,
                            (mCurFrameIdx + 1)*mFrameWidth,
                            mFrameHeight);
    canvas.save();
    canvas.clipRect(mCurRect);
    canvas.drawBitmap(mExplodeBmp, srcRect, mCurRect, null);
    canvas.restore();
}

一开始计算的srcRect,表示的就是和mCurFrameIdx对应的绘制部分。

 

         其实,不光是爆炸效果,我们的每一类Enemy都是具有自己的动画的。它们的绘制机理和爆炸效果一致,我们就不赘述了。下面只贴出三类Enemy的角色动画图:



 

4.5  Player

        现在我们来看玩家控制的角色——Player类。它和Enemy最大的不同是,它是直接由玩家控制的。玩家想把它移到什么地方,他就得乖乖地移到那个地方去,为此它必须能够处理MotionEvent。

 

4.5.1   doWithTouchEvent()

public boolean doWithTouchEvent(MotionEvent event)
{
    int x = (int)event.getX();
    int y = (int)event.getY();
   
    switch (event.getAction())
    {
    case MotionEvent.ACTION_DOWN:
        mOffsetX = x - mCurRect.left;
        mOffsetY = y - mCurRect.top;
        return true;
       
    case MotionEvent.ACTION_UP:
        mOffsetX = mOffsetY = 0;
        return true;
       
    case MotionEvent.ACTION_MOVE:
        int curX = x - mOffsetX;
        int curY = y - mOffsetY;
       
        if (curX < 0)
        {
            curX = 0;
        }
        if (curY < 0)
        {
            curY = 0;
        }
        if (curX + mWidth  > GlobalInfo.screenW)
        {
            curX = GlobalInfo.screenW - mWidth;
        }
        if (curY + mHeight > GlobalInfo.screenH)
        {
            curY = GlobalInfo.screenH - mHeight;
        }
        mCurRect.set(curX, curY, curX+mWidth, curY+mHeight);
        return true;
       
    default:
        break;
    }
    return false;
}

         注意,为了保证良好的用户体验,我们需要在用户点击屏幕之时,先计算一下手指点击处和Player对象当前所在位置之间的偏移量,以后在处理ACTION_MOVE时,还需用x、y减去偏移量。这样,就不会出现Player对象从旧位置直接跳变到手指点击处的情况。

 

4.5.2   碰撞判断

        现在我们来说说碰撞处理。在飞机游戏里,一种典型的碰撞情况就是被子弹击中啦。对于Player来说,它必须逐个判断敌人发出的子弹,看自己是否已和某个子弹亲密接触,如果是的话,那么Player就得减血,如果没血可减了,就算被击毙了。

 

        对于简单的游戏而言,我们只需判断子弹所占的Rect范围是否和Player所占的Rect范围有交集,如果是的话,就可以认为发生碰撞了。当然,为了增加一点儿趣味性,我们是用一个比Player Rect更小的矩形来和子弹Rect比对的,这样可以出现一点儿子弹和Player擦身而过的惊险效果。

 

         在GameManager的execLogic()的最后一步,会调用execCollsionLogic()函数。该函数的代码如下:

private void execCollsionLogic()
{
    mPlayer.doWithCollision(mEnemyBulletsMgr);
    mEnemyMgr.doWithCollision(mPlayerBulletsMgr);
}

意思很简单,Player需要和所有enemy发出的子弹进行比对,而每个enemy需要和Player发出的子弹比对。我们只看Player的doWithCollision()函数,代码如下:

public void doWithCollision(BulletsManager bulletsMgr)
{
    if (mState == STATE_EXPLODE || mState == STATE_DEAD)
    {
        return;
    }
   
    ArrayList<Bullet> bullets = bulletsMgr.getBullets();
    Iterator<Bullet> itor = bullets.iterator();
    int insetWidth  = (int)((mCurRect.right - mCurRect.left) * 0.2);
    int insetHeight = (int)((mCurRect.bottom - mCurRect.top) * 0.15);
    Rect effectRect = new Rect(mCurRect);
    effectRect.inset(insetWidth, insetHeight);
   
    while (itor.hasNext())
    {
        Bullet b = itor.next();
        Rect bulletRect = b.getRect();
        if (effectRect.intersect(bulletRect))
        {
            b.doCollide();
            doCollide(b.getPower());
        }
    }
}

其中那个effectRect就是比Player所占矩形更小一点儿的矩形啦。我们遍历BulletsManager中的每个子弹,一旦发现哪个子弹和effectRect有交集,就执行doCollide()。

private void doCollide(int power)
{
    if (mState == STATE_ADJUST || mState == STATE_EXPLODE || mState == STATE_DEAD)
    {
        return;
    }
   
    if (power < 0)
    {
        // kill me directly
        mState = STATE_EXPLODE;
    }
    else if (power > 0)
    {
        mMyHP -= power;
        if (mMyHP <= 0)
        {
            mMyHP = 0;
            mState = STATE_EXPLODE;
        }
        else
        {
            mState = STATE_ADJUST;
            mAdjustCounter = 0;
        }
    }
}

         如果写得复杂一点儿的话,不同enemy发出的子弹的威力应该是不一样的。不过在本游戏中,每颗子弹的威力都定为1了。也就是说,传入doCollide()的power参数的值总为1。每次碰撞时,Player就减一滴血(mMyHP -= power),然后立即跳变到STATE_ADJUST状态或STATE_EXPLODE状态。

 

         另一方面,enemy和Player发出的子弹也有类似的判断,只是判断条件更加宽松一些,这样可以给玩家增加一点儿射击的爽快感,呵呵。关于这部分的代码我们就不重复贴了。

 

4.5.3   被击中后的闪烁效果

        Player需要完成的另一个效果是被击中后,闪烁一段很短的时间,在这段时间内,它会暂时处于无敌状态,这样做可以避免玩家出现被多颗子弹同时击中而被瞬杀的情况。为此我们设计了一个“调整状态”,就是我们刚刚看到的STATE_ADJUST状态啦。

 

         一旦Player被击中,只要它的mMyHP(血值)没有减到0,那么它立即跳变到STATE_ADJUST。在这种状态下,我们不再每次都绘制Player图片了,而是隔一帧绘制一次,这样就可以达到闪烁的效果了。当然这个状态的维持时间很短,我们会记录一个mAdjustCounter计数变量,每次执行execLogic()会给这个计数器加1,直到加到6,我们就从STATE_ADJUST状态,跳变回普通状态(STATE_ALIVE状态)。

public void execLogic()
{
    if (mState == STATE_ALIVE)
    {
        doFireBulletLogic();
    }
    else if (mState == STATE_EXPLODE)
    {
        doExplode();
    }
    else if (mState == STATE_ADJUST)
    {
        doFireBulletLogic();
       
        mAdjustCounter++;
        if (mAdjustCounter > 6)
        {
            mState = STATE_ALIVE;
            mAdjustCounter = 0;
        }
    }
}


public void drawFrame(Canvas canvas)
{
    boolean shouldDraw = true;
   
    if (mState == STATE_DEAD)
    {
        Log.d("Player", "mState == STATE_DEAD");
        return;
    }
    else if (mState == STATE_ADJUST)
    {
        if (mAdjustCounter % 2 == 0)
        {
            shouldDraw = false;
        }
    }
    else if (mState == STATE_EXPLODE)
    {
        // should draw
    }
   
    Log.d("Player", "mState == " + mState);
    if (shouldDraw)
    {
        Rect src = new Rect(0, 0, mPlayerBmp.getWidth(), mPlayerBmp.getHeight());
        canvas.drawBitmap(mPlayerBmp, src, mCurRect, null);
    }
}<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span>

4.6  GameInfoPanel

        飞机游戏还需要一个简单的“信息显示板”,来显示一些重要的信息。在本游戏中,我只显示了Player的剩余血量(每滴血用一个红心表示),大家有兴趣可以再添加玩家分数等信息。

 

         我们设计的信息显示板是GameInfoPanel,它的逻辑非常简单:

public void execLogic()
{
    mPlayerHP = mPlayer.getHP();
}

只是简单地记录一下Player的血量而已。

 

         绘制时,它根据所记录的血量值绘制相应的红心图片就可以了:

public void drawFrame(Canvas canvas)
{
    Rect    src     = new Rect(0, 0, mHPBmp.getWidth(), mHPBmp.getHeight());
    Rect dest    = new Rect();
   
    for (int i = 0; i < mPlayerHP; i++)
    {
        dest.left   = mRect.left + i * mHPiconWidth;
        dest.top    = mRect.top;
        dest.right  = dest.left + mHPiconWidth;
        dest.bottom = dest.top + mHPiconHeight;
       
        canvas.drawBitmap(mHPBmp, src, dest, null);
    }
}

5      尾声

至此,我们已经把这个小游戏的主要设计方面都讲到了。当然,因为这个游戏只是我为了好玩而写的一个demo程序,所以肯定有很多地方并不完备,这个我想大家也是可以理解的。那么就先说这么多吧。最后让我们来贴两张游戏截图,乐呵一下。

        

用C++语言写游戏——打飞机 想玩游戏吗? 就到某位神犇这来吧! 这会告诉你很多游戏写法! 今天,神犇就开始书写第三期——打飞机!!! 很容易,只需要用脑袋想想即可,READY——GO! 我也希望大家多多捧场哦~~~ 阅读详情

相关推荐

C/C++实现简单打飞机小游戏【初版】

文章目录C版本点子初版1.1 静止的飞机初版1.2 动态飞机(使用按键控制飞机移动)初版1.3 动态飞机(按空格发射和关闭激光)初版1.4 动态飞机(按空格发射一次激光,移动时关闭)初版1.5 飞机打靶(添加和击毁靶子)初版1.6 移动的靶子初版1.7 分数统计和显示进阶版2.1进阶版2.2进阶版2.3 C版本 点子 实现一个字符飞机,按asdw键后改变飞机的坐标位置(x, y),控制飞机上下左右...

memcpy0的博客 9657

C语言——简单的飞机小游戏

简单的飞机小游戏

qq_74326574的博客 2030

最简单的飞机游戏

最简单的飞机游戏c语言代码。。。。。。。。。。。。。。。

Python代码实现飞机大战

文章目录经典飞机大战一.游戏设定二.我方飞机三.敌方飞机四.发射子弹五.发放补给包六.主模块 经典飞机大战 源代码以及素材资料(图片,音频)可从下面的github中下载: 飞机大战源代码以及素材资料github项目地址链接 ————————————————————————————————————————————————————————— 不知道大家有没有打过飞机,喜不喜欢打飞机。当我第一次接触这个东西的时候,我的内心是被震撼到的。第一次接触打飞机的时候作者本人是身心愉悦的,因为周边的朋友都在打飞机, 每

逐梦er的博客 5万+

C语言实现的简单打飞机小游戏

用C语言实现的最简单的 打飞机小游戏,

飞机游戏源代码简单AI

自做飞机游戏源代码实现在飞机的AI,可以用于飞机游戏当中的导弹的制作

c语言编程一个静态的飞机,只有来求助各位大神了。。用C语言写的一个飞机游戏...

该楼层疑似违规已被系统折叠隐藏此楼查看此楼#include#include#include#include#define N 35void print(int a[][N]);//输出函数void movebul(int a[][N]);//子弹移动函数void movepla(int a[][N]);//敌机移动函数void setting();//设置函数void menu();//菜单函数...

weixin_42608318的博客 231

简单的flash飞机游戏源代码

本人期中作业,实现了发射子弹,动态文本,boss的跟踪子弹

c语言入门级小游戏·飞机(2.0版)| 激发你的编程兴趣(100~150行代码)

声明:本游戏参考《c语言课程设计与游戏开发实践教程》。首先放一个小游戏视频效果(右边界有点凌乱,影响美观,但不影响效果,多多见谅😋)game飞机2.0版如何?这个单单用字符来完成的简略版小游戏,很适合c语言的新手锻炼实践能力(理论即可)。这个2.0版的飞机小游戏实际上是在我上次发的1.0版基础上优化的()相比之下,2.0版不再有画面和光标的频闪问题,发射方式从激光变成子弹,障碍物可移动并重现,有计分功能。

x18037177724的博客 3205

简单飞机游戏

作者学directx时仿VC中做的简单的飞机游戏,需要DelphiX组件(可在本站下载)。

Virtuoso ADE Explorer实战技巧:从基础操作到高级仿真

本文深入解析了Virtuoso ADE Explorer在模拟电路仿真中的核心价值与实战技巧。作为Cadence平台的专业工具,它专为高效、系统化的设计空间探索而生,能大幅提升PVT验证、参数扫描和蒙特卡洛分析的效率。文章从基础界面操作、并行仿真管理,到高级的参数扫描、数据报告生成及蒙特卡洛结果深度剖析,提供了全面的避坑指南与工作流优化建议,帮助工程师从重复劳动中解放,专注于电路设计与性能优化。

ios99的博客 905

c语言入门级小游戏·飞机(1.0版)| 激发你的编程兴趣(50~100行代码)

声明:本游戏参考《c语言课程设计与游戏开发实践教程》。先来放一个效果图怎么样,真的是新手级别吧?可以通过wasd四个键控制飞机的移动,按空格键可以发射激光击中前方的障碍物*,击中后障碍物消失。下面来看看如何制作吧。

x18037177724的博客 1万+

GPS从入门到放弃(一) --- GPS基础原理

GPS从入门到放弃(一) — GPS基础原理 GPS,全称Global Positioning System,已经广泛应用于我们的日常生活中了,现在的智能手机 里都会自带GPS定位功能。这是一个美国的全球定位系统,虽然我们现在也有北斗了,但毕竟GPS搞的早,所以先从它开始研究起。 整个GPS系统分三大部分: 地面站 卫星 接收机 地面站负责监控。它们通过接收、测量各个卫星信号,计算卫星的运行轨...

tyst08的专栏 2万+

用C语言写飞机小游戏

这是自己实训写的代码,现在分享给大家,直接贴代码,主要用到光标定位,和多线程 运行效果 下面是全部代码 #include<stdio.h> #include<stdlib.h> #include<time.h> #include <conio.h> #include <windows.h> int time_=400;...

qq_40173146的博客 5079

YOLOv13改进策略【多YAML融合】| HWD + DSC3k2_PConv + Detect_MBConv

本文记录的是利用HWD + DSC3k2_PConv + Detect_MBConv改进YOLOv13,分别涉及骨干、颈部和检测头部分的改进。一方面按照此配置,其工作量及创新程度能够满足论文发表的需求,另一方面是一些难以融合多个YAML的举例,以帮助大家理解如何将多个YAML整合到一个YAML中。小波下采样:一个简单但有效的语义分割下采样模块。块由两个主要块组成:无损特征编码块和特征表示学习块。HWD模块与其他下采样模块对比:保留信息能力:传统的下采样方法(如最大池化、平均池化和步幅卷积等)会导致信息丢失,

Limiiiing的博客 500

Java 大视界 -- 基于 Java+Flink 构建实时电商交易风控系统实战(436)

本文介绍基于Java+Flink构建实时电商交易风控系统的实战经验。系统采用分层架构设计,包含数据采集层、实时计算层、规则引擎层、数据存储层和应用服务层,实现毫秒级风险识别与拦截。核心组件包括Flink 1.17处理交易数据流、Drools规则引擎动态匹配风险规则、Redis缓存热点数据等。文章详细提供了开发环境配置清单和Maven依赖说明,确保系统具备低延迟(≤200ms)、高吞吐(10万TPS)和高可用性(99.99%)特性。该方案已通过生产环境验证,可有效应对恶意刷单、盗刷支付等电商交易风险。

【青云交】华为云云享专家 | 阿里云开发者社区专家博主 技术圈个人影响力前 9 | 博客之星 TOP12 优快云 首位四榜(原力榜 / 作者周榜 / 领军人物 / 综合热榜)榜首,破平台纪录! 苏州地区全榜霸榜,感恩全网十多万粉丝同行! 3943

用java写一个简单的飞机大战游戏

制作一个简单的飞机大战 注意!!!!!,图片素材在我的资源里有。 下面代码排序,非先后顺序。请看清楚类名 Airplane类 package Flyplane; public class Airplane extends FlyingObject implements Enemy{ private int yspeed=2; public Airplane() { image=ShootGame.airplane; width=image.getWidt

javavavavav的博客 5218

工业级C#+YOLOv8缺陷检测系统:准确率98.5%、延迟<50ms的完整实现

本文分享了基于C#和YOLOv8的工业级表面缺陷检测系统实现方案。针对汽车零部件冲压件检测需求(60件/分钟,准确率>98%,延迟<100ms),作者对比了多种技术方案后选择了C#+YOLOv8+ONNX Runtime的组合,最终实现98.5%准确率和42ms延迟。 系统采用分层模块化架构,包含硬件层、采集层、推理层、业务层和控制层。核心优势包括:1)C#在工业环境下的稳定性和集成便利性;2)YOLOv8对复杂缺陷的泛化能力;3)ONNX Runtime GPU加速提升性能。文章详细介绍了硬件

这里只有干货:从 Modbus 通信到 MES 对接,从 YOLO 训练到工控机部署,带你搞定工业软件开发全流程。 1143

用python写(飞机大战小游戏)

w'cwc下面我们进入详细教程: 一、首先我们先建一个文件夹 planewars(名字随便取): 然后用我们python中的pycharm打开这个文件,我们飞机大战的项目就在这进行 二、我们要写这个小游戏要用到pygame模 补充: Pygame是一个利用SDL库的写就的游戏库,Pygame就是Python中使用它的一个库。 1.安装pygame模块 其安装命令如下:pip install pygame 我们直接在pycharm中打开 命令行(终端) 下载(我已...

qq_62870237的博客 1万+

【UVM实战】第七章:UVM中的寄存器模型(1)寄存器模型简介

寄存器模型简介~

悟已往之不谏 知来者之可追 2073

深入理解SQL注入中的union select 1,2,3....

UNION 用于合并两个查询的结果集

渗透之路,攻防之间皆学问 2万+

基于HTML的飞机射击游戏

本篇博文将分享一篇基于HTML的简单的飞机射击游戏,下方是玩家飞机,可按空格键能不断地发射子弹,上方是随机出现的敌方飞机。玩家可以通过键盘的方向键控制自己飞机的移动,当玩家飞机的子弹碰到敌方飞机时,敌方飞机出现爆炸效果。

不脱发的程序猿 1万+

华为 MetaERP 总账模块依托 “交易即核算” 的事件驱动架构,与 Oracle EBS 相比,更强调业务事件自动触发财务动作、实时数据同步和智能规则引擎,实现业务与财务的深度融合

华为MetaERP总账模块采用"交易即核算"架构,相比Oracle EBS实现了三大突破:1)业务事件自动触发财务动作,如采购收货自动生成暂估凭证;2)业务财务数据实时同步,支持即时分析;3)内置智能规则引擎,实现自动匹配、核销和结转。该模块覆盖采购、销售、资产、薪酬等全业务场景,支持多维核算和关联交易自动抵消,显著提升核算效率与准确性。其中采购暂估、销售结转等场景实现全自动化处理,较EBS减少80%手工操作。

金牌架构师 227

Qt游戏编程——飞机大战

效果图: 源码下载: 这篇文章记录了我用一周的时间从零Qt基础到制作出飞机大战的过程。 Qt相比MFC封装好了大量函数,而且非常有条理。飞机大战的实现主要用到了Qt的信号与槽机制、事件响应机制、计时器、随机数、QPainter绘图以及最关键的图形视图框架,在做飞机大战之前,建议掌握以下内容: 1.了解信号与槽机制,熟练使用connect函数 2.了解Qt时间响应机制,并学会响应鼠标、键盘

hao_zong_yin的博客 3万+

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

用 JavaScript 写一个小游戏打飞机

以上就是 基于 js 制作一个飞机大战,不懂得也可以在评论区里问我或私聊我询问,以后会持续发布一些新的功能,敬请关注。

m0_62241283的博客 2432

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

上一篇: 说说Android应用的persistent属性
下一篇: 深入讲解Android Property机制
悠然红茶
博客等级 码龄26年 270粉丝 27原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

悠然红茶

原来还有打赏功能,试一下呦。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值