scenemodel.java

格斗类小游戏 没什么好说的了 真的真的

        if(cter.desX==-1&&cter.desY==-1) {
            dx = cter.mX - mPlayer.mX;
            dy = cter.mY - mPlayer.mY;
        } else {
            if(cter.desX>0) {
                if(cter.mX<=cter.desX) {
                    cter.desX=-1;
                    cter.desY=-1;
                    //isTalk=true;
                    return;
                }
            } else {
                if(cter.mX+20<0) {
                    cter.setState(HF.STATE_DIE);
                    return;
                }
            }
            System.out.println("当前"+""+cter.mX+" " +cter.mY);
            System.out.println("目标"+""+cter.desX+" " +cter.desY);
            
            dx = cter.mX - cter.desX;
            dy = cter.mY - cter.desY;
        }
        if(cter.mAttackDelay>0){
            cter.mAttackDelay--;
        }
        //判断是否在攻击范围内
        switch(cter.mType) {
            case HF.DADAO:
            case HF.CHANGMAO:
            case HF.CIKE:
            case HF.JIANDUN:
            case HF.PAWN:
            case HF.COCK:
            {
                if (dx * dx<500&&dy * dy < 5) {
                    if(cter.desX==-1&&cter.desY==-1) {
                        if(cter.mAttackDelay <=0){//攻击的延时到了
                            cter.setState(HF.STATE_ATTACK);
                            cter.mAttackDelay = atkDelay; //设置每次攻击的时间延时间隔
                            if (mPlayer.mState != HF.STATE_DIE) {
                                mPlayer.mLife = mPlayer.mLife - aLife;
                                if(dx<-5) {
                                    //mPlayer.setPictureIndex (4);
                                    mPlayer.mHurtCount = true;
                                } else {
                                    //mPlayer.setPictureIndex (5);
                                    mPlayer.mHurtCount = true;
                                }
                                if (mPlayer.mLife <= 0) {
                                    mPlayer.mLife = 0;
                                    mPlayer.setState(HF.STATE_DIE);
                                }
                            }
                        }
                        return; //可以进行攻击了，跳过移动位置的判断
                    }
                }
            }
            break;
            case HF.GONGJIAN:
            {
                if (dx * dx<30000&&dy * dy < 5) {
                    if(cter.desX==-1&&cter.desY==-1) {
                        if(cter.mAttackDelay <=0){//攻击的延时到了
                            cter.setState(HF.STATE_ATTACK);
                            cter.mAttackDelay = atkDelay; //设置每次攻击的时间延时间隔
                            //if (mPlayer.mState != HF.STATE_DIE) {
                            enemyFire(cter.mDirection == HF.STATE_MOVE_RIGHT?cter.mX+13:cter.mX-13,cter.mY-10,cter.mDirection );
                            //}
                        }
                        return; //可以进行攻击了，跳过移动位置的判断
                    }
                }
            }
            break;
        }
        if (Math.abs(dx)>Math.abs(dy)) {
            if (dx < 0){
                cter.setState(HF.STATE_MOVE_RIGHT);
            } else{
                cter.setState(HF.STATE_MOVE_LEFT);
            }
        } else{
            if (dy < 0){
                cter.setState(HF.STATE_MOVE_DOWN);
            } else {
                cter.setState(HF.STATE_MOVE_UP);
            }
        }
        //未在攻击范围内，让敌兵靠近小爱
        if (Math.abs(dx) < cStep) {
            if(cter.desX==-1&&cter.desY==-1)
                cter.mX = mPlayer.mX;
            else
                cter.mX = cter.desX;
        } else {
            if (dx > 0) {
                cter.mX = cter.mX - cStep;
            } else {
                cter.mX = cter.mX + cStep;
            }
        }
        if (Math.abs(dy) < cStep) {
            if(cter.desX==-1&&cter.desY==-1)
                cter.mY = mPlayer.mY;
            else
                cter.mY = cter.desY;
        } else {
            if (dy > 0)
                cter.mY = cter.mY - cStep;
            else
                cter.mY = cter.mY + cStep;
        }
    }
    
    //更新场景中的敌兵信息，让他们攻击主角小爱
    private void refreshEnemies() {
        if(mPlayer.mState == HF.STATE_DIE ||mPlayer.mUsed == false){
            return;
        }
        //更新敌兵的状态
        for(int i=2;i<MAX_PAWN;i++){
            if(mPawns[i].mUsed == true){
                //if(mPawns[i].mX<mSceneWidth+20)
                refreshCharacter(mPawns[i],HF.STEP,2,15);
            }
        }
        //更新敌兵头目的状态
        if(mCock.mUsed == true){
            refreshCharacter(mCock,HF.STEP,mAttackLife[mLevel-1],10);
        }
        if(mPreCock.mUsed == true) {
            refreshCharacter(mPreCock,HF.STEP,mAttackLife[mLevel-1],10);
            if(mPreCock.mState == HF.STATE_DIE) {
                mCock.mUsed = true;
                mCock.setState(HF.STATE_MOVE_LEFT);
            }
            
        }
    }
    
    //判断是否游戏结束了
    protected boolean isGameOver() {
        return !mPlayer.mUsed;
    }
    
    //判断是否过关了
    protected boolean isPassLevel() {
        //过关的条件是打败了敌兵头目
        return mCock.mUsed==false&&mCock.mLife<=0;
    }
    
    //更新主角的信息
    private void refreshPlayer() {
        if(mPlayer.mUsed == false) return;
        if(mPlayer.mState == HF.STATE_DIE) return;//已经死亡了
        int step = 8;//步伐的大小
        switch(mPlayer.mState){
            case HF.STATE_MOVE_LEFT:
                mPlayer.mX -= step;
                if(mPlayer.mX <=8) mPlayer.mX =8;
                break;
            case HF.STATE_MOVE_RIGHT:
                mPlayer.mX += step;
                int distance = 0;
                if(mSceneIndex<mSceneCounts[mLevel-1]){
                    if (mPlayer.mX + distance > (mSceneWidth / 2)) {
                        int dx = mPlayer.mX + distance - mSceneWidth / 2;
                        mPlayer.mX = mSceneWidth / 2 - distance;
                        translateScene(dx, 0);
                    }
                }else{
                    distance = 15;
                    if (mPlayer.mX + distance > mSceneWidth) {
                        int dx = mPlayer.mX + distance - mSceneWidth;
                        mPlayer.mX = mSceneWidth - distance;
                        translateScene(dx, 0);
                    }
                }
                break;
            case HF.STATE_MOVE_UP:
                mPlayer.mY -= step;
                if(mPlayer.mY<BORDER_UP-10){
                    mPlayer.mY = BORDER_UP-10;
                }
                break;
            case HF.STATE_MOVE_DOWN:
                mPlayer.mY += step;
                if(mPlayer.mY+17>BORDER_DOWN){
                    mPlayer.mY = BORDER_DOWN-17;
                }
                break;
            case HF.STATE_ATTACK:
            {
                if(mPlayer.mFrameIndex<1)
                    return;
                int x = 0,y =0;
                if(mPlayer.mDirection == HF.STATE_MOVE_LEFT){
                    x = mPlayer.mX-13;
                } else if(mPlayer.mDirection == HF.STATE_MOVE_RIGHT){
                    x = mPlayer.mX+13;
                }
                y = mPlayer.mY-7;
                fire(x,y,mPlayer.mDirection);//发射一颗子弹
                
            }
            break;
            default:
                break;
        }
    }
    
    //更新场景中的物品
    private void refreshSceneObjects() {
        int step = 20;//子弹的移动速度
        for(int i=0;i<MAX_BULLET;i++){
            if(mBullets[i].mUsed == true){
                if(mBullets[i].mDirection == HF.STATE_MOVE_RIGHT){
                    mBullets[i].mX += step;
                    if(mBullets[i].mX>mSceneWidth) {
                        mBullets[i].reset();//越出的场景，移去
                        for(int bi=0;bi<mBFloor.length;bi++){
                            if(mBFloor[bi].mUsed==false){
                                mBFloor[bi].mUsed=true;
                                mBFloor[bi].mX=mBullets[i].mX-18;
                                mBFloor[bi].mY=mBullets[i].mY+10;
                                break;
                            }
                        }
                    }
                } else if(mBullets[i].mDirection == HF.STATE_MOVE_LEFT){
                    mBullets[i].mX -= step;
                    if(mBullets[i].mX+21<0) {
                        mBullets[i].reset();//越出的场景，移去
                        for(int bi=0;bi<mBFloor.length;bi++){
                            if(mBFloor[bi].mUsed==false){
                                mBFloor[bi].mUsed=true;
                                mBFloor[bi].mX=mBullets[i].mX+30;
                                mBFloor[bi].mY=mBullets[i].mY+10;
                                break;
                            }
                        }
                    }
                }
            }
        }
        for(int i=0;i<MAX_ENEMY_BULLET;i++){
            if(mEnemyBullets[i].mUsed == true){
                if(mEnemyBullets[i].mDirection == HF.STATE_MOVE_RIGHT){
                    mEnemyBullets[i].mX += step;
                    if(mEnemyBullets[i].mX>mSceneWidth) mEnemyBullets[i].reset();//越出的场景，移去
                } else if(mEnemyBullets[i].mDirection == HF.STATE_MOVE_LEFT){
                    mEnemyBullets[i].mX -= step;
                    if(mEnemyBullets[i].mX+21<0) mEnemyBullets[i].reset();//越出的场景，移去
                }
            }
        }
    }
    
    //刷新场景的信息
    protected void refresh() {
        
        refreshPlayer();
        refreshSceneObjects();
        refreshEnemies();
        checkCollison();
        
        //else
        //{
        //}
    }
    
    //变换场景中的物品坐标
    private void translateScene(int dx,int dy) {
        
        if((mSceneIndex)>=mSceneCounts[mLevel-1])
            return;//已经到达了本关的最后一个场景
        mBufferGraphics.translate(dx,0);//水平迁移坐标
        sceneCount[1]+=dx/2;
        sceneCount[2]+=dx/8;
        if(mBufferGraphics.getTranslateX()>=mSceneWidth){
            //越出了一个游戏屏幕了
            mSceneIndex++;
            mBufferGraphics.translate(-mBufferGraphics.getTranslateX(),0);
            createScene(mSceneWidth,0);
            if((mSceneIndex)==mSceneCounts[mLevel-1]){
                switch(mLevel) {
                    case 1:
                    case 2:
                        mPreCock.mUsed = true;
                        //mPreCock.desX=mSceneWidth-40;
                        //mPreCock.desY=BORDER_UP+BORDER_DOWN>>1;
                        mPreCock.setState(HF.STATE_MOVE_LEFT);