在Android游戏中更新玩家得分

Question

更新adt并使eclipse行为更稳定一些。我决定下一个合乎逻辑的步骤是在我的乒乓球游戏中添加一个评分系统。还没有碰撞检测，但是当球在屏幕上移动时，它会更新得分。我意识到的问题是分数可能在我的线程类中更新，但从未在oncreate方法中。我如何修改我的代码以允许线程之外的分数更新？下面是代码

这里与主类中创建

package com.TheGame; 


import android.app.Activity; 
import android.os.Bundle; 
import android.util.Log; 
import android.view.Menu; 
import android.view.MenuItem; 
import android.widget.EditText; 
import android.widget.TextView; 
import com.TheGame.gameview.LunarThread; 
import android.graphics.*; 
import android.widget.*; 
public class basicgame extends Activity { 
    /** Called when the activity is first created. */ 





    /** A handle to the thread that's actually running the animation. */ 
    private LunarThread mLunarThread; 

    /** A handle to the View in which the game is running. */ 
    private gameview mLunarView; 



    public void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.main); 


     // score.setTextSize(20); 

     mLunarView = (gameview) findViewById(R.id.lunar); 
     TextView score =(TextView)findViewById(R.id.scoreview); 
     score.setText(mLunarView.playerscore); 
     mLunarView.postInvalidate(); 
     // score.setTextColor(Color.RED); 
     //setContentView(mLunarView); 
     // setContentView(linearLayout); 
     // mLunarView.addView(score); 
     //mLunarThread = mLunarThread.getThread(); 


     // give the LunarView a handle to the TextView used for messages 



    } 
} 

，这里是线程和视图类

package com.TheGame; 

import android.content.Context; 
import android.graphics.*; 
import android.content.res.Resources; 
import android.graphics.Bitmap; 
import android.graphics.BitmapFactory; 
import android.graphics.Canvas; 
import android.graphics.Color; 
import android.graphics.Paint; 
import android.graphics.RectF; 
import android.graphics.drawable.Drawable; 
import android.os.Bundle; 
import android.os.Handler; 
import android.os.Message; 
import android.util.AttributeSet; 
import android.view.KeyEvent; 
import android.view.SurfaceHolder; 
import android.view.SurfaceView; 
import android.view.View; 
import android.widget.EditText; 
import android.widget.TextView; 
import android.util.*; 
import android.view.*; 
import android.app.Activity; 
import android.view.Window; 
import android.util.DisplayMetrics; 
import android.graphics.drawable.BitmapDrawable; 


public class gameview extends SurfaceView implements SurfaceHolder.Callback 
{ 
    public float player1y =0; 
    public float player2y =0; 
    public String playerscore = ""; 
    int player1score =0; 
     int player2score = 0; 
    public class LunarThread extends Thread {   



      int x =0; 
      int y = 0; 
      int velx = 3; 
      int vely = 3; 



      DisplayMetrics display = new DisplayMetrics(); 



      Drawable background; 
      private Drawable mBackgroundImage; 


      private Drawable player1; 
      private Drawable player2; 




      /** Message handler used by thread to interact with TextView */ 
      private Handler mHandler; 


      /** Indicate whether the surface has been created & is ready to draw */ 
      private boolean mRun = false; 

      /** Scratch rect object. */ 


      /** Handle to the surface manager object we interact with */ 
      private SurfaceHolder mSurfaceHolder; 



      public LunarThread(SurfaceHolder surfaceHolder, Context context, 
        Handler handler) { 

       // get handles to some important objects 
       mSurfaceHolder = surfaceHolder; 
       mHandler = handler; 
       mContext = context; 

       Resources res = context.getResources(); 
       // cache handles to our key sprites & other drawables 

       playerscore = "Player 1: "+ player1score +" Player 2: " + player2score; 
       // load background image as a Bitmap instead of a Drawable b/c 
       // we don't need to transform it and it's faster to draw this way 
       mBackgroundImage = getResources().getDrawable(R.drawable.icon); 
       background = getResources().getDrawable(R.drawable.kittens); 
       player1 = getResources().getDrawable(R.drawable.paddle); 
       player2 = getResources().getDrawable(R.drawable.paddle); 

      } 




      @Override 
      public void run() { 
       while (mRun) { 

        Canvas c = null; 
        try { 
         c = mSurfaceHolder.lockCanvas(null); 
         synchronized (mSurfaceHolder) { 

          doDraw(c); 

         } 
        } finally { 
         // do this in a finally so that if an exception is thrown 
         // during the above, we don't leave the Surface in an 
         // inconsistent state 
         if (c != null) { 
          mSurfaceHolder.unlockCanvasAndPost(c); 
         } 
        } 

       } 
      } 


      public void setRunning(boolean b) { 
       mRun = b; 
      } 


      public void setSurfaceSize(int width, int height) { 
       // synchronized to make sure these all change atomically 
       synchronized (mSurfaceHolder) { 



       } 
      } 


      boolean doKeyDown(int keyCode, KeyEvent msg) { 
       synchronized (mSurfaceHolder) { 




        return false; 
       } 
      } 


      private void doDraw(Canvas canvas) { 

       canvas.save(); 


       canvas.drawColor(Color.BLACK); 
       //Rect moverrect = mBackgroundImage.copyBounds(); 
       background.setBounds(0,0,canvas.getWidth(),canvas.getHeight()); 
       mBackgroundImage.setBounds(x, y,x+ 100,y+ 100); 

       player1.setBounds(0, (int)player1y, 50, (int)player1y+75); 
       player2.setBounds(canvas.getWidth()-50,(int)player2y,canvas.getWidth(),(int)player2y+75); 
       // Log.i("game","X "+x + " Y "+y); 
       background.draw(canvas); 
       mBackgroundImage.draw(canvas); 
       player1.draw(canvas); 
       player2.draw(canvas); 
       if(player1y<0) 
       { 
       player1y =0; 
       } 
       if(player1y>canvas.getHeight()-75) 
       { 
       player1y = canvas.getHeight()-75; 
       } 
       if(player2y<0) 
       { 
       player2y =0; 
       } 
       if(player2y>canvas.getHeight()-75) 
       { 
       player2y = canvas.getHeight()-75; 
       } 
       int sizex = canvas.getWidth()-100; 
       int sizey = canvas.getHeight()-100; 

       x+=velx; 
       y+=vely; 


       if(x<0) 
       { 
       //x=0; 
       //velx*=-1; 
       x = canvas.getWidth()/2; 
       player2score++; 

       } 
       if(y<0) 
       { 
       y=0; 
       vely*=-1; 
       } 
       if(x>sizex) 
       { 
       //x=sizex; 
       //velx*=-1; 
       x = canvas.getWidth()/2; 
       player1score++; 
       } 
       if(y>sizey) 
       { 
       y=sizey; 
       vely*=-1; 
       } 



       canvas.restore(); 
       // 
       // invalidate(); 

      }    

     public LunarThread getThread() { 
      return thread; 
     } 

     private float mPosX; 
     private float mPosY; 

     private float mLastTouchX; 
     private float mLastTouchY; 

     private static final int INVALID_POINTER_ID = -1; 

    // The ‘active pointer’ is the one currently moving our object. 
    private int mActivePointerId = INVALID_POINTER_ID; 



     /* Callback invoked when the surface dimensions change. */ 
     public void surfaceChanged(SurfaceHolder holder, int format, int width, 
       int height) { 
      thread.setSurfaceSize(width, height); 
     } 

     /* 
     * Callback invoked when the Surface has been created and is ready to be 
     * used. 
     */ 
     public void surfaceCreated(SurfaceHolder holder) { 
      // start the thread here so that we don't busy-wait in run() 
      // waiting for the surface to be created 
      thread.setRunning(true); 
      thread.start(); 
     } 

     /* 
     * Callback invoked when the Surface has been destroyed and must no longer 
     * be touched. WARNING: after this method returns, the Surface/Canvas must 
     * never be touched again! 
     */ 
     public void surfaceDestroyed(SurfaceHolder holder) { 
      // we have to tell thread to shut down & wait for it to finish, or else 
      // it might touch the Surface after we return and explode 
      boolean retry = true; 
      thread.setRunning(false); 
      while (retry) { 
       try { 
        thread.join(); 
        retry = false; 
       } catch (InterruptedException e) { 
       } 
      } 
} 
    } 

    /** Handle to the application context, used to e.g. fetch Drawables. */ 
    private Context mContext; 

    /** Pointer to the text view to display "Paused.." etc. */ 
    private TextView mStatusText; 
    @Override 
    public boolean onTouchEvent(MotionEvent ev) { 
      final int action = ev.getAction(); 

      switch (action) { 

      case MotionEvent.ACTION_MOVE: { 
       // Find the index of the active pointer and fetch its position 
      int pointerCount = ev.getPointerCount(); 


      for (int i = 0; i < pointerCount; i++) { 
      float p1y = ev.getY(i); 
      float p1x = ev.getX(i); 
       if(p1x<300) 
       { 
        player1y = p1y; 
       } 
       else if(p1x>300) 
       { 
        player2y = p1y; 
       } 
      } 
       //player1y = p1y; 

       invalidate(); 
       break; 
      } 

      } 
      return true; 


     } 

    /** The thread that actually draws the animation */ 
    public LunarThread thread; 

     public gameview(Context context, AttributeSet attrs) 
     { 
      super(context, attrs); 

      // register our interest in hearing about changes to our surface 
      SurfaceHolder holder = getHolder(); 
      holder.addCallback(this); 

      // create thread only; it's started in surfaceCreated() 
      thread = new LunarThread(holder, context, new Handler()); 






      // setFocusable(true); // make sure we get key events 
      this.setFocusableInTouchMode(true); 
     } 
     public void surfaceDestroyed(SurfaceHolder holder) { 
      // we have to tell thread to shut down & wait for it to finish, or else 
      // it might touch the Surface after we return and explode 
      boolean retry = true; 
      thread.setRunning(false); 
      while (retry) { 
       try { 
        thread.join(); 
        retry = false; 
       } catch (InterruptedException e) { 
       } 
      } 
     } 
     public void surfaceCreated(SurfaceHolder holder) { 
      // start the thread here so that we don't busy-wait in run() 
      // waiting for the surface to be created 
      thread.setRunning(true); 
      thread.start(); 
     } 
     public void surfaceChanged(SurfaceHolder holder, int format, int width, 
       int height) { 
      thread.setSurfaceSize(width, height); 
     } 
     @Override 
     public void onDraw(Canvas canvas) 
     { 

     } 



} 

请记住我是新来的Android游戏开发和尝试通过我对xna开发的了解来模拟它的样子。我善待着月球登陆代码，试图让背景发生并从那里开始工作。我想尝试从最基本的游戏代码开始，但我可能已经删除了我内脏中的重要方法。这就是为什么变量有月球词汇的原因。

感谢

编辑

正如有人谁仍是新的网站我的意见并没有真正工作了。代码在我的复制和粘贴中根本没有格式化。 我的问题是你将如何实现处理程序来获得分数和文本更新？有没有在线的例子，我可以很容易地整合它，或者我把自己放在一个洞里？

谢谢

Answer 1

有可以使用这里的几个方法：

1. 使用AsyncTask的后台处理
2. 创建的GUI（主）线程Handler，并张贴Runnables或消息吧。
3. 使用Activity.runOnUiThread

如果你很可能会移植到另一个平台，使用一个Runnable有道理的，因为与正确的抽象，您可以在J2SE

希望使用javax.microedition.lcdui.Display.callSerially在J2ME或javax.swing.SwingUtilities.invokeLater这有助于，

菲尔Lello

Answer 2

不知道你是否看过Asynctask。 http://developer.android.com/reference/android/os/AsyncTask.html

我发现这是UI线程和非UI线程之间通信的最佳方式。