你丫的唯一 2013-06-26 09:36 采纳率: 0%

Android打砖块代码其中系统说格式错误求帮助

我这边有一个打砖块代码，我将它移植到我的按钮事件触发里提示我格式错误下面前两个是打砖块代码，后两个是转到我的里面之后的，标注了，请帮忙。
package ab.cc;

import android.app.Activity;

import android.os.Bundle;

import android.util.DisplayMetrics;

import android.view.KeyEvent;

import android.view.MotionEvent;

import android.view.Window;
import android.view.WindowManager;

public class BaomingActivity extends Activity
{

BallView myView;

static int screenWidth;

static int screenHeight;

/** Called when the activity is first created. */
@Override

public void onCreate(Bundle savedInstanceState)
{

super.onCreate(savedInstanceState);

/* 定义DisplayMetrics对象 */

DisplayMetrics dm = new DisplayMetrics();

/* 取得窗口属性 */

getWindowManager().getDefaultDisplay().getMetrics(dm);

/* 窗口的宽度 */

screenWidth = dm.widthPixels;

    /* 窗口的高度 */

screenHeight = dm.heightPixels;
//

setTitle("宽"+screenWidth+" 高"+screenHeight);

    /* 设置为无标题栏 */

requestWindowFeature(Window.FEATURE_NO_TITLE);

/* 设置为全屏模式 */

getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN);

myView = new BallView(this);

   //设置显示GameSurfaceView视图

setContentView(myView);
}//end of onCreate()

   //触笔事件

public boolean onTouchEvent(MotionEvent event)
{

return true;
}


   //按键按下事件

public boolean onKeyDown(int keyCode, KeyEvent event)
{

switch (keyCode)
    {

//菜单按键-设为初始菜单

case KeyEvent.KEYCODE_MENU:

myView.resetGame();
    //重新开始

break;

//中间按键

case KeyEvent.KEYCODE_DPAD_CENTER:

myView.ball_isRun = !myView.ball_isRun;//开始//暂停

    break;

//左方向键

case KeyEvent.KEYCODE_DPAD_LEFT:

        if(myView.ball_isRun){

    if(myView.board_left<=myView.board_x_move)

        {

myView.board_left=0;

    myView.board_right=myView.board_length;

    }else{

    myView.board_left-=myView.board_x_move;

            myView.board_right-=myView.board_x_move;}

}

             break;

//右方向键

case KeyEvent.KEYCODE_DPAD_RIGHT:
if(myView.ball_isRun){

    if(screenWidth-myView.board_right<=myView.board_x_move )

{
myView.board_left=screenWidth-myView.board_length;

                                myView.board_right=screenWidth;

}else{
                myView.board_left+=myView.board_x_move;

                                    myView.board_right+=myView.board_x_move;

        }
        }

        break;

        //上方向键

case KeyEvent.KEYCODE_DPAD_UP:

    if(myView.ball_isRun){

    if( myView.board_alterable_top==myView.board_default_top)

{

    myView.board_alterable_top-=myView.boardYadd;

            myView.board_alterable_bottom-=myView.boardYadd;
            }
        }

        break;  
    //下方向键

   case KeyEvent.KEYCODE_DPAD_DOWN:

if(myView.ball_isRun){

if( myView.board_alterable_top==myView.board_default_top-myView.boardYadd )

{
                myView.board_alterable_top=myView.board_default_top;

myView.board_alterable_bottom=myView.board_alterable_top+myView.board_thickness;
            }
        }

break;

//返回键
case KeyEvent.KEYCODE_BACK:

this.finish();

break;

}//end switch
return false;
}

//按键弹起事件

public boolean onKeyUp(int keyCode, KeyEvent event)
{

    return true;
}

public boolean onKeyMultiple(int keyCode, int repeatCount, KeyEvent event)
{

return true;
}

}

package ab.cc;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.RadialGradient;
import android.graphics.Shader;
import android.util.Log;
import android.view.SurfaceHolder;
import android.view.SurfaceView;

public class BallView extends SurfaceView implements
SurfaceHolder.Callback, Runnable {

//线程延时控制 
final int ball_sleep=1;//毫秒，延时越大，球速越慢
final int ball_r= 8;//小球半径
final float ball2_r= 8;//底下滚珠小球半径
final int ballXorYadd = 4;//小球的基本位移。测试可行值：2，4

//获取屏幕宽度和高度
int screen_width;//320;
int screen_height;//480;

//砖的属性
int brick_width;//每块砖宽
int brick_height;//每块砖高
boolean brick_exist[];//砖是否存在
int k ;// 列//到for循环里才初始化
int j ;// 行
int brick_left = brick_width*(k-1);//到判断语句才初始化
int brick_right = brick_width*k;
int brick_top = brick_height*j;
int brick_bottom = brick_height*(j+1);

//挡板的属性
int board_length;//挡板长度:80比较合适，可以随意修改,但别超过screen_width
final int boardYadd = 16;//按上下键时挡板y方向位移量。经验证4、8、16可以，12不行
final int board_x_move = 30;//挡板x方向位移量:可以随意自定义
int board_left;//挡板左侧（可变）
int board_right;//挡板右侧（可变）
int board_thickness;//挡板厚度
int board_default_top;//即435,挡板的top面初始位置
int board_alterable_top;//挡板上侧（可变）
int board_alterable_bottom;//挡板下侧（可变）

int ball_default_x;//球的初始x坐标
int ball_default_y;//球的初始y坐标
//球的即时坐标（可变）：
int ball_x;//球心横坐标
int ball_y;//球心纵坐标
//球的前一步的y坐标
int ball_previous_y;
int ball_x_speed;//球的横向偏移量//可变
int ball_y_speed;//球的纵向偏移量//可变
boolean ball_isRun;//球是否在动
// 控制循环
boolean mbLoop;
// 定义SurfaceHolder对象
SurfaceHolder mSurfaceHolder = null;
//获得分数
int score;
/* 唤醒渐变渲染 */
Shader mRadialGradient = null;

//------------------------------------------------------------------------------------------------------//
public BallView(Context context) {
super(context);
// 实例化SurfaceHolder
mSurfaceHolder = this.getHolder();
// 添加回调
mSurfaceHolder.addCallback(this);
this.setFocusable(true);

    //获取屏幕宽度和高度
    screen_width = BaomingActivity.screenWidth;//320
    screen_height = BaomingActivity.screenHeight;//480

    //砖的属性
    brick_width = screen_width/5;//每块砖宽64
    brick_height = screen_height/15;//每块砖高32

    //挡板的属性
    board_length = screen_width/4;//挡板长度:80比较合适，可以随意修改,但别超过screen_width
    board_left = (screen_width-board_length)/2;//挡板左侧（可变）
    board_right = (screen_width+board_length)/2;//挡板右侧（可变）
    board_thickness = 5;//挡板厚度
    board_default_top = 13*screen_height/15;//即435,挡板的top面初始位置
    board_alterable_top = board_default_top;//挡板上侧（可变）
    board_alterable_bottom = board_alterable_top+board_thickness;//挡板下侧（可变）

    ball_default_x = screen_width/2;//球的初始x坐标
    ball_default_y = board_default_top - ball_r;//球的初始y坐标
    //球的即时坐标（可变）：
    ball_x = ball_default_x;
    ball_y = ball_default_y;
    //球的前一步的y坐标
    ball_previous_y = 0;
    ball_x_speed = ballXorYadd;//球的横向偏移量
    ball_y_speed = ballXorYadd;//球的纵向偏移量

    mbLoop = true;
    ball_isRun = false;
    score=0;

    brick_exist = new boolean[25];
    for (int i = 0; i < 25; i++) {
        brick_exist[i] = true;
    }
    /* 构建RadialGradient对象，设置半径的属性 */
    mRadialGradient = new RadialGradient(ball_x, ball_y, ball_r,//球中心坐标x,y,半径r
            new int[]{Color.WHITE,Color.BLUE,Color.GREEN,Color.RED,Color.YELLOW},//颜色数组
            null,//颜色数组中每一种颜色对应的相对位置，为空的话就是平均分布，由中心向外排布
            Shader.TileMode.REPEAT);//渲染模式：重复
}

public void resetGame(){
    ball_isRun = false;
    score =0;//分数
    ball_x_speed = ballXorYadd;//球的横向偏移量
    ball_y_speed = ballXorYadd;//球的纵向偏移量
    ball_x = screen_width/2;//球心起始横坐标
    ball_y = board_default_top - ball_r;//球心起始纵坐标
    board_left = (screen_width-board_length)/2;//挡板左侧
    board_right = (screen_width+board_length)/2;//挡板右侧
    board_alterable_top = board_default_top;//挡板上侧
    board_alterable_bottom = board_alterable_top+board_thickness;//挡板下侧
    for (int i = 0; i < 25; i++) {
        brick_exist[i] = true;
    }
}

//---------------------------------绘图循环开始----------------------------------
public void run() {

    while (mbLoop&&!Thread.currentThread().isInterrupted()) {
        try {
            Thread.sleep(ball_sleep);
        }
        catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        //球的前一步y坐标
        ball_previous_y = ball_y;

        if (ball_isRun) {
            ballRunning();// 让小球移动
            boardPositionCheck();//检测挡板是否处于“中线”位置，是就随小球上升一步，直至到“上线”
            hitWallCheck();//墙壁碰撞检测
            hitBoardCheck();//挡板碰撞检测
            hitBrickCheck();//砖块碰撞检测
        }
        synchronized (mSurfaceHolder) 
        {
            Draw();
        }
    }
}
//---------------------------------绘图循环结束----------------------------------
//------------------------------------------------------------------------------

//让小球移动
public void ballRunning() {
    ball_x += ball_x_speed;
    ball_y -= ball_y_speed;
}
//朝左或朝右碰撞后小球水平方向逆向
public void ballLeftOrRightHit() {
    ball_x_speed *= -1;
}
//朝上或朝下碰撞后小球竖直方向逆向
public void ballUpOrDownHit() {
    ball_y_speed *= -1;
}

public void ballcornerHit() {
    ball_x_speed *= -1;
    ball_y_speed *= -1;
}

public void ballStraightUp() {//功能没实现，这是多余代码
    ball_x_speed = 0;//注意在其他地方恢复
    ball_y_speed *= -1;
}

//-------------------墙壁碰撞检测开始-------------------------------------
public void hitWallCheck() {
    // 左碰墙
    if (ball_x <= ball_r && 
        ball_y >= ball_r && ball_y <= screen_height) 
    {
        ballLeftOrRightHit();
    // 右碰墙
    }
    if (ball_x >= screen_width - ball_r && //不能写为 else if,因为可能恰好碰到角落。
               ball_y >= ball_r && ball_y <= screen_height) 
    {
        ballLeftOrRightHit();
    }
    // 上碰墙
    if (ball_x >= ball_r && ball_x <= screen_width - ball_r && 
             ball_y <= ball_r + brick_height) //、、、、、、、、、、、、、、、25号修改
    {
        ballUpOrDownHit();
    }
    // 下碰墙
    if (ball_x >= ball_r && ball_x <= screen_width - ball_r && 
             ball_y >= screen_height-ball_r) 
    {
        ballUpOrDownHit();
        if(score<=10){
            score = 0;
        }
        else score-=10;
    }
}
//-------------------墙壁碰撞检测结束-------------------------------------

//-----------------------------挡板碰撞检测开始---------------------------
public void hitBoardCheck() {
    // 下碰挡板正面
    if (ball_x >= ball_r && ball_x <= screen_width - ball_r && //在屏幕内，起码条件
        ball_x >= board_left && ball_x <= board_right && //在挡板X域上方
        ball_y == board_alterable_top - ball_r &&//球面与挡板相切
        ball_previous_y <= board_alterable_top - ball_r  //确定球是从上方下落
        )
    {
        if(board_alterable_top==board_default_top-boardYadd ){//如果弹簧伸张，挡板位于上线
            ballHitBoardlower();//作用：ball_y_move减小；挡板被打下;小球Y向运动反向
        }
        else if(board_alterable_top==board_default_top){//如果弹簧压缩，挡板位于下线
            boardHitBallHigher();//作用：ball_y_move增加；挡板弹上;小球Y向运动反向
        }
    }
    //斜碰挡板右上角//经验证有效
    else if(Math.pow(board_right-ball_x, 2)+Math.pow(board_alterable_top-ball_y,2)<=Math.pow(ball_r, 2)&&
            ball_x>board_right && ball_y<board_alterable_top)
    {
        ballcornerHit();
    }
    //斜碰挡板的左上角//经验证有效
    else if(Math.pow(board_left-ball_x, 2)+Math.pow(board_alterable_top-ball_y,2)<=Math.pow(ball_r, 2)&&
            ball_x<board_left && ball_y<board_alterable_top)
    {
        ballcornerHit();
    }
}
//-----------------------------挡板碰撞检测结束--------------------------

private void boardHitBallHigher() {//增强
    ballUpOrDownHit();//小球Y方向反向,ball_y_speed变为正数
    if(ball_y_speed == ballXorYadd ){
        ball_y_speed += ballXorYadd;//离开挡板后小球Y方向速度增强
    }
    if( boardYadd > ball_y_speed ){//在线程这一轮，小球上升多少，挡板就上升多少。
        board_alterable_top = board_default_top - ball_y_speed;
        board_alterable_bottom= board_alterable_top+board_thickness;//挡板下层面
    }
}

//检测挡板是否处于“中线”位置，是就随小球上升一步，直至到“上线”
private void boardPositionCheck() {//还可直接利用球的位置刷新，board_top与球心相差ball_r
    if(board_alterable_top < board_default_top && board_alterable_top > board_default_top-boardYadd){
        //挡板随球上升
        if(board_alterable_top - ball_y_speed >= board_default_top-boardYadd){
            board_alterable_top -= ball_y_speed;//挡板上层面
            board_alterable_bottom= board_alterable_top+board_thickness;//挡板下层面
        }
        else{
            board_alterable_top = board_default_top-boardYadd;//挡板上层面
            board_alterable_bottom= board_alterable_top+board_thickness;//挡板下层面
        }
    }
}

private void ballHitBoardlower() {//减弱
    board_alterable_top=board_default_top;
    board_alterable_bottom=board_default_top+board_thickness;//挡板被打退
    ballUpOrDownHit();//小球Y方向反向
    if(ball_y_speed==2*ballXorYadd){
        ball_y_speed -= ballXorYadd;//小球Y方向速度减弱
    }
}

//砖块碰撞检测开始-----------------------------------------------------------
public void hitBrickCheck() {
    for (int i = 0; i <25 ; i++) {
    if (brick_exist[i]) {
        k = i % 5+1;// 1,2,3,4,5循环
        j = i / 5+1;// 1,1,1,1,1;2,2,2,2,2,;...;5,5,5,5,5
        brick_left = brick_width*(k-1);
        brick_right = brick_width*k;
        brick_top = brick_height*j;
        brick_bottom = brick_height*(j+1);
        //朝下碰砖的top面 AAAAAAAAAAAAAAAAAAAAA
        if(ball_x >= brick_left && ball_x <= brick_right &&
           ball_y >= brick_top-ball_r && ball_y < brick_top) 
        {
            ballUpOrDownHit();
            brick_exist[i] = false;
            score+=4;
            //朝下正碰2砖中间，i砖右上角检测
            if(k!=5 && ball_x == brick_right)//如果不是第5列砖的右侧边
            {
                //如果砖[i+1]存在
                if(brick_exist[i+1]){
                    brick_exist[i+1] = false;
                    score+=4;
                }
            }
            //朝下正碰2砖中间，i砖左上角检测
            else if(k!=1 && ball_x == brick_left)//如果不是第1列砖的左侧边
            {
                //如果砖[i-1]存在
                if(brick_exist[i-1]){
                    brick_exist[i-1] = false;
                    score+=4;
                }
            }
        }
        //朝上碰砖的bottom面 BBBBBBBBBBBBBBBBB
        else if(ball_x >= brick_left && ball_x <= brick_right &&
                ball_y > brick_bottom&& ball_y <= brick_bottom + ball_r )
        {
            ballUpOrDownHit();
            brick_exist[i] = false;
            score+=4;
            //朝上正碰2块砖中间--i砖的右下角检测
            if(k!=5 && ball_x == brick_right) //如果不是第5列砖的右侧边
            {
                if(brick_exist[i+1]){//如果砖[i+1]存在
                    brick_exist[i+1] = false;
                    score+=4;
                }
            }
            //朝上正碰2块砖中间--i砖的左下角检测
            else if(k!=1 && ball_x == brick_left) //如果不是第1列砖的左侧边
            {
                if(brick_exist[i-1]){//如果砖[i-1]存在
                    brick_exist[i-1] = false;
                    score+=4;
                }
            }
        }
        //朝右碰砖的left面CCCCCCCCCCCCCCCCC
        else if(ball_x >= brick_left -ball_r&&ball_x < brick_left&&
           ball_y >= brick_top && ball_y <= brick_bottom)
        {
            ballLeftOrRightHit();
            brick_exist[i] = false;
            score+=4;
            //朝右正碰2块砖中间，左下角检测
            if(j!=5 && ball_y == brick_bottom)//如果不是第5行砖的下侧边
            {
                if(brick_exist[i+5]){//如果砖[i+5]存在
                    brick_exist[i+5] = false;
                    score+=4;
                }
            }
            //朝右正碰2块砖中间，左上角检测
            else if(j!=1 && ball_y == brick_top)//如果不是第1行砖的上侧边
            {
                if(brick_exist[i-5]){//如果砖[i-5]存在
                    brick_exist[i-5] = false;
                    score+=4;
                }
            }
        }
        //朝左碰砖的right面DDDDDDDDDDDDDDDDDD
        else if(ball_x >= brick_right && ball_x <= brick_right+ball_r&&
           ball_y >= brick_top && ball_y <= brick_bottom)
        {
            ballLeftOrRightHit();
            brick_exist[i] = false;
            score+=4;
            //朝左正碰2块砖中间，右下角检测
            if(j!=5 && ball_y == brick_bottom )//如果不是第5行砖的下侧边
            {
                if(brick_exist[i+5]){//如果砖[i+5]存在
                    brick_exist[i+5] = false;
                    score+=4;
                }
            } 
            //朝左正碰2块砖中间，右上角检测
            else if(j!=1 && ball_y == brick_top )//如果不是第1行砖上侧边
            {
                if(brick_exist[i-5]){//如果砖[i-5]存在
                    brick_exist[i-5] = false;
                    score+=4;
                }
            }
        }
        /////////////////////////////////////////
        //斜碰i砖的左下角EEEEEEEEEEEEEEEEEEEEEEEE
        else if(( i-1<0||(i-1>=0&&!brick_exist[i-1]) ) &&
                (i+5>=25||(i+5<25&&!brick_exist[i+5]) )&&
                Math.pow(brick_left-ball_x, 2)+Math.pow(brick_bottom-ball_y,2)<=Math.pow(ball_r, 2)&&
                ball_x>brick_left-ball_r && ball_x<brick_left && 
                ball_y>brick_bottom && ball_y<brick_bottom+ball_r )
        {
            ballcornerHit();
            brick_exist[i] = false;
            score+=4;
        }
        //斜碰i砖的右下角FFFFFFFFFFFFFFFFFFFFFFFFFF
        else if( (i+1>=25||(i+1<25&&!brick_exist[i+1]) )&&
                 (i+5>=25||(i+5<25&&!brick_exist[i+5]) )&&
                Math.pow(brick_right-ball_x, 2)+Math.pow(brick_bottom-ball_y,2)<=Math.pow(ball_r, 2)&&
                ball_x>brick_right&&ball_x<brick_right+ball_r&&
                ball_y>brick_bottom&&ball_y<brick_bottom+ball_r )
        {
            Log.v("----------", "right bottom hit"+i+":"+brick_exist[i]);
            ballcornerHit(); 
            brick_exist[i] = false;
            score+=4;
        }
        //斜碰i砖的右上角GGGGGGGGGGGGGGGGGGGGGGGG
        else if( (i+1>=25||(i+1<25&&!brick_exist[i+1]) )&&
                (i-5<0||(i-5>0&&!brick_exist[i-5]) )&&
                Math.pow(brick_right-ball_x, 2)+Math.pow(brick_top-ball_y,2)<=Math.pow(ball_r, 2)&&
                ball_x>brick_right && ball_x<brick_right+ball_r&&
                ball_y>brick_top-ball_r && ball_y<brick_top)          
        {
            ballcornerHit();
            brick_exist[i] = false;
            score+=4;
        }
        //斜碰i砖的左上角HHHHHHHHHHHHHHHHHHHHHHHHHH
        else if((i-1<0||(i-1>=0&&!brick_exist[i-1])) &&
                (i-5<0||(i-5>=0&&!brick_exist[i-5])) &&
                Math.pow(brick_left-ball_x, 2)+Math.pow(brick_top-ball_y,2)<=Math.pow(ball_r, 2)&&
                ball_x>brick_left-ball_x && ball_x<brick_left &&
                ball_y>brick_top-ball_r && ball_y<brick_top )
        {
            ballcornerHit();
            brick_exist[i] = false;
            score+=4;
        }
    }//end if
    }//end for  
}//end hitBrickCheck()
//砖块碰撞检测结束-----------------------------------------------------------

//------------------------------------------
public boolean gameOver(){
    int count = 0;
    for(boolean s:brick_exist){
        if(!s){
            count++;
        }
    }
    if(count == 25){
        return true;
    }else{
        return false;
    }

}
//------------------------------------------

//---------------绘图方法开始------------------------
public void Draw() {
    // 锁定画布，得到canvas
    Canvas canvas = mSurfaceHolder.lockCanvas();
    if (mSurfaceHolder == null || canvas == null) {
        return;
    }
    // 绘图
    Paint mPaint = new Paint();
    // 设置取消锯齿效果
    mPaint.setAntiAlias(true);

    mPaint.setColor(Color.BLACK);
    // 绘制矩形--背景
    canvas.drawRect(0, 0, screen_width, brick_height-2, mPaint);

    mPaint.setColor(Color.GREEN);
    // 绘制矩形--背景
    canvas.drawRect(0, brick_height-2, screen_width, screen_height, mPaint);

    mPaint.setColor(Color.RED);//设置字体颜色
    mPaint.setTextSize(brick_height-7);//设置字体大小
    canvas.drawText("得分："+score, 0, brick_height-7, mPaint);

    // 绘制顶层挡板````````````````````````````````````````````````````````25号修改
    mPaint.setColor(Color.BLACK);//设置颜色 
    mPaint.setStrokeWidth(4);//设置粗细
    canvas.drawLine(0, brick_height-2, screen_width, brick_height-2, mPaint);

    for (int i = 0; i <25 ; i++) {
        if (brick_exist[i]) {
            k = i % 5+1;// 1,2,3,4,5循环
            j = i / 5+1;// 1,1,1,1,1;2,2,2,2,2,;...;5,5,5,5,5
            brick_left = brick_width*(k-1);
            brick_right = brick_width*k;
            brick_top = brick_height*j;
            brick_bottom = brick_height*(j+1);

            mPaint.setStyle(Paint.Style.FILL);// 设置实心画笔
            mPaint.setColor(Color.YELLOW);
            canvas.drawRect(brick_left+1, brick_top+1, brick_right-1,brick_bottom-1, mPaint);

            mPaint.setStyle(Paint.Style.STROKE);// 设置空心画笔
            mPaint.setStrokeWidth(2);//设置粗细
            mPaint.setColor(Color.BLUE);
            canvas.drawRect(brick_left+3, brick_top+3, brick_right-3,brick_bottom-3, mPaint);
        }
    }
    // 设置实心画笔
    mPaint.setStyle(Paint.Style.FILL);
    {
        mPaint.setShader(mRadialGradient);
        canvas.drawCircle(ball_x, ball_y, ball_r, mPaint);
    }   

    Paint mPaint2 = new Paint();
        // 设置取消锯齿效果
    mPaint2.setAntiAlias(true); 
    // 设置实心画笔
    mPaint2.setStyle(Paint.Style.FILL);
    {   
    mPaint2.setColor(Color.BLACK);
    /* 绘制矩形挡板 */
    canvas.drawRect(board_left, board_alterable_top, board_right, board_alterable_bottom,mPaint2);
    float board2_bottom = screen_height - 2*ball2_r;//164
    float board2_top = board2_bottom - 4;//160
    //线段端点坐标数组
    float x0 = board_left+(board_right-board_left)/4;
    float y0 = board_alterable_bottom;//440或者444
    float springAdd = (board2_top- board_alterable_bottom)/8;//即2.5或者2：弹簧小线段的y向长度
    float springWidth = 5.0f;//弹簧小线段的x向长度
    float x1 = x0 - springWidth;
    float y1 = y0 + springAdd;
    float x2 = x0 + springWidth;
    float y2 = y0 + 3*springAdd;
    float x3 = x1 ;
    float y3 = y0 + 5*springAdd;
    float x4 = x2;
    float y4 = y0 + 7*springAdd;
    float x5 = x0 ;
    float y5 = board2_top;//即460 
    float between_spring = (board_right-board_left)/2;
    float pts[] = { x0,y0,x1,y1,
                    x1,y1,x2,y2,
                    x2,y2,x3,y3,
                    x3,y3,x4,y4,
                    x4,y4,x5,y5};
    float pts2[] = {x0+between_spring,y0, x1+between_spring,y1,
                    x1+between_spring,y1, x2+between_spring,y2,
                    x2+between_spring,y2, x3+between_spring,y3,
                    x3+between_spring,y3, x4+between_spring,y4,
                    x4+between_spring,y4, x5+between_spring,y5};
    mPaint2.setStrokeWidth(2);//设置弹簧粗细
    //绘制2个弹簧
    canvas.drawLines(pts, mPaint2);
    canvas.drawLines(pts2, mPaint2);
    //绘制下层挡板
    canvas.drawRect(board_left, board2_top, board_right, board2_bottom,mPaint2);
    mPaint2.setColor(Color.BLACK);//
    // 绘制最下面的两个“轮子”(圆心x,圆心y,半径r,p) 
    canvas.drawCircle(board_left+ball2_r, screen_height-ball2_r, ball2_r, mPaint2);//圆
    canvas.drawCircle(board_right-ball2_r, screen_height-ball2_r, ball2_r, mPaint2);
    mPaint2.setColor(Color.WHITE);//
    canvas.drawPoint(board_left+ball2_r, screen_height-ball2_r, mPaint2);//绘制左轮轮心
    canvas.drawPoint(board_right-ball2_r, screen_height-ball2_r, mPaint2);//绘制右轮轮心

    }//实心画笔mPaint2结束

    if(gameOver()){

// mbLoop = false;//注释掉的话GAME OVER后也可重启
ball_isRun = false;
mPaint2.setColor(Color.BLACK);//设置字体颜色
mPaint2.setTextSize(40.0f);//设置字体大小
canvas.drawText("GAME OVER", screen_width/32+40, screen_height/16*9-70, mPaint2);
mPaint2.setTextSize(20.0f);//设置字体大小
canvas.drawText("Press \"MENU\" button to restart,",
screen_width/32, //320/32=10
screen_height/16*9, //480/16=30,30*9=270
mPaint2);
canvas.drawText("Press \"BACK\" button to exit.",
screen_width/32, //320/32=10
screen_height/16*10, //480/16=30,30*10=300
mPaint2);
}
// 绘制后解锁，绘制后必须解锁才能显示
mSurfaceHolder.unlockCanvasAndPost(canvas);
}// end of Draw()
//---------------------绘图方法结束-----------------------------------------------

// 在surface的大小发生改变时激发
public void surfaceChanged(SurfaceHolder holder, int format, int width,
        int height) {
}

// 在surface创建时激发
public void surfaceCreated(SurfaceHolder holder) {
    new Thread(this).start();// 开启绘图线程
}

// 在surface销毁时激发
public void surfaceDestroyed(SurfaceHolder holder) {
    // 停止循环
    mbLoop = false;
}

}

package sen.tan;

import android.app.Activity;
import android.graphics.Color;
import android.os.Bundle;
import android.util.DisplayMetrics;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.TextView;

public class dazhuankuaiActivity extends Activity {
BallView myview;
public static int screenWidth ;
public static int screenHeight;
private TextView textview;
Button kaishi,jieshu,guanyu;
ImageView image;
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
String string = "欢迎进入疯狂打砖块游戏";
image = (ImageView) this.findViewById(R.id.image);
image.setImageResource(R.drawable.img1);
textview =(TextView) this.findViewById(R.id.textview);
textview.setTextSize(20);
textview.setTextColor(Color.GREEN);
textview.setBackgroundColor(Color.RED);
textview.setText(string);
kaishi=(Button)findViewById(R.id.button1);
guanyu=(Button)findViewById(R.id.button2);
jieshu=(Button)findViewById(R.id.button3);
kaishi.setWidth(250);
guanyu.setWidth(200);
jieshu.setWidth(150);
kaishi.setTextSize(35);
guanyu.setTextSize(29);
jieshu.setTextSize(24);

    jieshu.setOnClickListener(new Button.OnClickListener(){
        public void onClick(View v)
        {
            dazhuankuaiActivity.this.finish();
        }


    });
    guanyu.setOnClickListener(new Button.OnClickListener(){
        public void onClick(View v){
            textview.setText("本游戏由邵明森和谭明星制作，此游戏控制左右按键，来回移动挡板，不让小球掉落，当小球把上方砖块全部打完时，游戏胜利");
        }
    });
    kaishi.setOnClickListener(new Button.OnClickListener(){
        public void onClick(View v){
            public void onCreate(Bundle savedInstanceState)这里显示的错误 显示的是上面两个括号标示不对。
            {
            super.onCreate(savedInstanceState);
            DisplayMetrics dm = new DisplayMetrics();
            getWindowManager().getDefaultDisplay().getMetrics(dm);
            screenWidth = dm.widthPixels;
            screenHeight = dm.heightPixels;             
            setTitle("宽"+screenWidth+"  高"+screenHeight);
            requestWindowFeature(Window.FEATURE_NO_TITLE); 
            getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN); 
            myview = new BallView(this);
            setContentView(myview);
            }
        }
        public boolean onTouchEvent(MotionEvent event)
        {
        return true;
        }
     public boolean onKeyDown(int keyCode, KeyEvent event)
        {
       switch (keyCode)
            {
    case KeyEvent.KEYCODE_MENU:

        myview.resetGame();
        break;

        case KeyEvent.KEYCODE_DPAD_CENTER:

        myview.ball_isRun = !myview.ball_isRun;

            break;
    case KeyEvent.KEYCODE_DPAD_LEFT:
            if(myview.ball_isRun){

            if(myview.board_left<=myview.board_x_move)

                {

        myview.board_left=0;

            myview.board_right=myview.board_length;

            }else{

            myview.board_left-=myview.board_x_move;

                    myview.board_right-=myview.board_x_move;}
    }

                     break;
    case KeyEvent.KEYCODE_DPAD_RIGHT:
    if(myview.ball_isRun){
            if(screenWidth-myview.board_right<=myview.board_x_move )
     {
                        myview.board_left=screenWidth-myview.board_length;

                                        myview.board_right=screenWidth;
            }else{
                        myview.board_left+=myview.board_x_move;
                        myview.board_right+=myview.board_x_move;
                }
                }
             break;

         case KeyEvent.KEYCODE_DPAD_UP:
            if(myview.ball_isRun){
            if( myview.board_alterable_top==myview.board_default_top)
    {
            myview.board_alterable_top-=myview.boardYadd;
            myview.board_alterable_bottom-=myview.boardYadd;
                    }
                }
            break;  
         case KeyEvent.KEYCODE_DPAD_DOWN:
        if(myview.ball_isRun){
        if( myview.board_alterable_top==myview.board_default_top-myview.boardYadd )
        {
                        myview.board_alterable_top=myview.board_default_top;
        myview.board_alterable_bottom=myview.board_alterable_top+myview.board_thickness;
                    }
                }
        break;  
        case KeyEvent.KEYCODE_BACK:
        this.finish();
        break;  
    }
        return false;
        }
     public boolean onKeyUp(int keyCode, KeyEvent event)
        {
            return true;
        }
    public boolean onKeyMultiple(int keyCode, int repeatCount, KeyEvent event)
        {
        return true;
        }
    }
    );
    }

}

写回答
好问题 0 提建议
追加酬金
关注问题
分享
邀请回答
编辑收藏删除结题
收藏举报

1条回答

关注

码龄粉丝数原力等级 --

被采纳

被点赞

采纳率
专家-赤兔[在线] 全栈领域优质创作者 2023-09-27 10:53
关注
该回复引自免费微信小程序-皆我百晓生:

很抱歉，当前代码量暂无法处理，所以我不能直接帮助调试格式错误的问题。建议您先进行初步的排查定位，尽量缩小问题范围，并提供恰到的问题和报错以及相应的代码，我将能够更准确地帮助您解决格式错误的问题。

通常情况下，格式错误可能是因为代码中的语法错误、拼写错误或者缺少必要的库或导入语句。

在处理格式错误时，可以尝试以下几个步骤：

仔细检查错误提示：格式错误通常会提供具体的错误信息和行号，可以仔细阅读该信息以确定错误出现的位置和原因。错误信息通常会提示具体的问题，例如拼写错误、缺少分号、括号未匹配等。

检查语法和拼写：检查代码中的语法和拼写错误，确保变量名、函数名和关键字拼写正确。

检查导入语句和库：如果代码中使用了某些库或依赖项，需要确认导入语句或者库的引用是否正确。确保所有需要的库都已正确导入。

使用调试工具：使用调试工具（例如Android Studio自带的调试功能）来跟踪代码运行过程中的错误，并查看变量的值和代码执行的流程，以便更好地定位问题。
解决无用
评论打赏
分享
举报

评论

按下Enter换行，Ctrl+Enter发表内容

报告相同问题？

关注问题

所做Android打砖块代码其中出错求教 android
2013-06-26 07:01

回答 2 已采纳 kaishi.setOnClickListener(new Button.OnClickListener(){ public void onClick(Vi
小球打砖块JAVA小游戏IDEA运行 java 有问必答
2021-06-09 08:50

回答 3 已采纳初始界面加上简单和困难的菜单项，两个模式调对应的参数
Cocos Creator。js代码如何实现砖块全部消失的情况下出现过关画面 javascript 开发语言
2019-04-18 11:44

回答 1 已采纳 https://blog.csdn.net/bark_ice/article/details/86234228
android游戏开发入门：贪吃蛇源代码分析
2013-10-28 22:46

zbird1988的博客 android游戏开发入门：贪吃蛇源代码分析分类： Android2011-07-19 21:57 9815人阅读评论(21) 收藏举报游戏android代码分析integerclassrandom 贪吃蛇是一款足够经典的游戏。它的经典，在于用户...
为什么排出来的砖块是乱的，不是整齐的呢？开发语言
2022-10-11 23:22

回答 2 已采纳估计是你的不同颜色造型砖块在画布里没有对齐
盖房子和开发程序哪个更难问答团队
2022-07-31 21:31

回答 1 已采纳难度的话，盖房子前期学习的成本更高，但是后面的话，会更加轻松一些，因为搞工程的都知道，这个到后面就是体力活还有人情世故了；除非你是设计师，还要考虑到结构构造以及外形设计上，否则你只是搬砖打工也不需要有
一个砖块排列的问题，考虑多个输出结果的实现，C语言 erlang golang r语言
2018-12-31 01:05

回答 1 已采纳 https://www.nowcoder.com/questionTerminal/e741cd831af94a55907c8ec6d63e71d7
android游戏开发入门：贪吃蛇源代码分析（入门极品）
2013-06-12 10:31

2022刘德华的博客这里的贪吃蛇的android实现，是SDK Samples中的开源例程。可能各位都有看过~界面如下图啦~ 作为一个刚入门或者还没入门的新手，着实花了我一些力气来理解这段代码。对于各种不懂的地方，...
. 简答题 1.某地需要搬运砖块，已知男人一人搬3块，女人一人搬2块，小孩两人搬一块。问用45人正好搬45块砖，有多少种搬法？ c# 有问必答
2021-11-05 11:01

回答 2 已采纳 #define _CRT_SECURE_NO_WARNINGS #include<iostream> using namespace std; int main(){ int n;
某工地需要搬运砖块，已知男人一人搬3块，女人一人搬2块，小孩两人搬1块。从键盘输入正整数N，用N人正好搬N块，问有多少种搬法？ c语言有问必答
2021-12-05 14:19

回答 1 已采纳三重循环就行了 #include <stdio.h> int main() { int n,count=0; int a,b,c; scanf("%d",&n);
关于俄罗斯方块问题，想的头都炸了!!! android
2017-02-25 13:36

回答 2 已采纳这就要看你的Shape构造函数是怎么定义的的了。
android-贪吃蛇开发
2016-01-27 16:52

逐梦_person的博客这里的贪吃蛇的android实现，是SDK Samples中的开源例程。可能各位都有看过~界面如下图啦~ 作为一个刚入门或者还没入门的新手，着实花了我一些力气来理解这段代码。对于各种不懂的地方，...
项目描述:（Python解） python
2023-01-29 20:09

回答 4 已采纳 n = int(input().strip()) dp = [0]*(n+1) for i in range(1, n+1): dp[i] = dp[i-1]+i print(sum(dp))
iOS开发非常全的三方库、插件、大牛博客等等
2018-06-16 17:52

金罗老师的博客 MJRefresh- 仅需一行代码就可以为UITableView或者CollectionView加上下拉刷新或者上拉刷新功能。可以自定义上下拉刷新的文字说明。具体使用看“使用方法”。（国人写）iOS学习加群：727474737 一起学习进步...
iOS开发工具,ios开发类库
2018-08-23 11:58

接iOS私活的博客 ,iosUI组件介绍,iOS开发常用工具整理,ios开发总结 1、通过CocoaPods安装项目名称项目信息 AFNetworking网络请求组件 FMDB本地数据库组件 SDWebImage多个缩略图缓存组件 UICKeyChainStore存放用户账号密码组件 ...
没有解决我的问题, 去提问

悬赏问题

¥15 如何修改pca中的feature函数
¥20 java-OJ-健康体检
¥15 rs485的上拉下拉，不会对a-b<-200mv有影响吗，就是接受时，对判断逻辑0有影响吗
¥15 使用phpstudy在云服务器上搭建个人网站
¥15 应该如何判断含间隙的曲柄摇杆机构，轴与轴承是否发生了碰撞？
¥15 vue3+express部署到nginx
¥20 搭建pt1000三线制高精度测温电路
¥15 使用Jdk8自带的算法，和Jdk11自带的加密结果会一样吗，不一样的话有什么解决方案，Jdk不能升级的情况
¥15 画两个图 python或R
¥15 在线请求openmv与pixhawk 实现实时目标跟踪的具体通讯方法

Android打砖块代码 其中系统说格式错误 求帮助

1条回答

悬赏问题

Android打砖块代码其中系统说格式错误求帮助