2015-09-07 1 views
0

j'ai bitmap se déplace à droite dans la toile je veux quand ce bitmap ferme à la bordure droite de l'écran à savoir: x Position < getWidth() avec certains faible valeur je veux traduire toile coordonnées de sorte que la toile elle-même se déplace également à côté du mouvement de l'image à l'intérieurandroid traduire les coordonnées de toile lorsque le bitmap en mouvement à l'intérieur se referme sur la bordure droite de l'écran?

un autre sens; je veux que le bitmap continue à se déplacer vers la droite de façon permanente et bien sûr quand il se ferme à la bordure droite de l'écran il disparaîtra bientôt ainsi je veux que la toile bouge avec moi pour rendre le bitmap toujours visible et je veux savoir comment pour définir la valeur de position x après traduire toile que

par exemple: quelque chose comme dans tous les jeux qui a un caractère se déplace vers la droite et l'écran se déplace également avec elle.

c'est le code qui trouve ici

http://www.edu4java.com/en/androidgame/androidgame3.html

et j'édita et maintenant le bitmap répète son mouvement quand il se ferme à la bordure droite de l'écran.

MyActivity.java 


    @Override 
    public void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 


     setContentView(new GameView(this)); 


    } 

et MyGameView (la classe principale de mon problème)

import android.content.Context; 
    import android.graphics.Bitmap; 
    import android.graphics.BitmapFactory; 
    import android.graphics.Canvas; 
    import android.graphics.Color; 
    import android.util.Log; 
    import android.view.SurfaceHolder; 
import android.view.SurfaceView; 

public class GameView extends SurfaceView { 
private Bitmap bmp; 
private SurfaceHolder holder; 
private GameLoopThread gameLoopThread; 
private int x = 0; 
private int xSpeed = 2; 

public GameView(Context context) { 
    super(context); 
    gameLoopThread = new GameLoopThread(this); 
    holder = getHolder(); 
    holder.addCallback(new SurfaceHolder.Callback() { 

     @Override 
     public void surfaceDestroyed(SurfaceHolder holder) { 
      boolean retry = true; 
      gameLoopThread.setRunning(false); 
      while (retry) { 
       try { 
        gameLoopThread.join(); 
        retry = false; 
       } catch (InterruptedException e) { 
       } 
      } 
     } 

     @Override 
     public void surfaceCreated(SurfaceHolder holder) { 
      gameLoopThread.setRunning(true); 
      gameLoopThread.start(); 
     } 

     @Override 
     public void surfaceChanged(SurfaceHolder holder, int format, 
            int width, int height) { 
     } 
    }); 
    bmp = BitmapFactory.decodeResource(getResources(), R.drawable.attention); 
} 

@Override 
protected void onDraw(Canvas canvas) { 

    super.onDraw(canvas); 


    if(x==getWidth()) 
    { 
     Log.e("cds","cdca"); 
     canvas.translate(x, 0); 

     x=10; 
    } 
    else 
    { 
     x = x + xSpeed; 

    } 

    if(canvas!=null) { 
     canvas.drawColor(Color.BLACK); 
     canvas.drawBitmap(bmp, x, 10, null); 
    } 

} 

}

GameLoopThread .JAVA

import android.graphics.Canvas; 

public class GameLoopThread extends Thread { 
static final long FPS = 10; 
private GameView view; 
private boolean running = false; 

public GameLoopThread(GameView view) { 
    this.view = view; 
} 

public void setRunning(boolean run) { 
    running = run; 
} 

@Override 
public void run() { 
    long ticksPS = 1000/FPS; 
    long startTime; 
    long sleepTime; 
    while (running) { 
     Canvas c = null; 
     startTime = System.currentTimeMillis(); 
     try { 
      c = view.getHolder().lockCanvas(); 
      synchronized (view.getHolder()) { 
       view.onDraw(c); 
      } 
     } finally { 
      if (c != null) { 
       view.getHolder().unlockCanvasAndPost(c); 
      } 
     } 
     sleepTime = ticksPS-(System.currentTimeMillis() - startTime); 
     try { 
      if (sleepTime > 0) 
       sleep(sleepTime); 
      else 
       sleep(10); 
     } catch (Exception e) {} 
    } 
    } 
} 
+0

une aide pour ce problème? – omar

Répondre

0

Comme vous l'avez mentionné « quelque chose comme dans tous les jeux qui un personnage se déplace vers la droite et l'écran se déplace également avec lui ".

vous devez définir une taille de fenêtre de la caméra (que ce soit la taille de l'écran 640X480) et dans le monde (1280X960)

vous devez également définir min et max décalage de la caméra

offsetMax_X= WorldSize_X-ViewPort_X; //(1280-640) 
offsetMax_Y= WorldSize_Y-ViewPort_Y; //(960-480) 
offsetMin_X=0; 
offsetMin_Y=0; 

Maintenant, vous devez calculer la position de la caméra par rapport au joueur (Sprites) afin que le joueur soit toujours au centre de l'écran.

cam_x=player_X-ViewPort_X/2; 
cam_y=player_Y-ViewPort_Y/2; 

Vérifiez la position de la caméra de sorte qu'elle ne dépasse pas les décalages.

if(cam_x>offsetMax_X) 
    cam_x=offsetMax_X; 
else if(cam_x<offsetMin_X) 
    cam_x=offsetMin_X; 
if(cam_y> offsetMax_Y) 
    cam_y=offsetMax_Y; 
else if(cam_y<offsetMin_Y) 
    cam_y=offsetMin_Y; 

vous devez également tanslate la toile

canvas.translate(-cam_x,-cam_y); 

Je vous écris une partie du code.créer une classe de caméra

class Camera{ 
    int ViewPort_X; 
    int ViewPort_Y; 
    int WorldSize_X; 
    int WorldSize_Y; 
    int offsetMax_X; 
    int offsetMax_Y; 
    int offsetMin_X; 
    int offsetMin_Y; 
    int CameraPos_X; 
    int CameraPos_Y; 
    Camera(int _ViewPort_X,int _ViewPort_Y,int _WorldSize_X,int _WorldSize_Y) 
    { 
    ViewPort_X=_ViewPort_X; 
    ViewPort_Y=_ViewPort_Y; 
    WorldSize_X=_WorldSize_X; 
    WorldSize_Y=_WorldSize_Y; 
    offsetMax_X= WorldSize_X- ViewPort_X; 
    offsetMax_Y= WorldSize_Y- ViewPort_Y; 
    offsetMin_X=0; 
    offsetMin_Y=0; 
    } 
    void updateCamera(int player_X,int player_Y) 
    { 
    CameraPos_X=player_X-ViewPort_X/2; 
    CameraPos_Y=player_Y-ViewPort_Y/2; 
    if(CameraPos_X>offsetMax_X) 
    CameraPos_X=offsetMax_X; 
    else if(CameraPos_X<offsetMin_X) 
    CameraPos_X=offsetMin_X; 
    if(CameraPos_Y> offsetMax_Y) 
    CameraPos_Y=offsetMax_Y; 
    else if(CameraPos_Y<offsetMin_Y) 
    CameraPos_Y=offsetMin_Y; 
    } 
} 

et créer caméra instance dans Gameview

Camera cam; 
int playerX; 
int playerY; 
public GameView(Context context) { 
    super(context); 
    cam=new Camera(640,480,1280,960); 
    playerX=width/2; 
    playerY=height/2; 
    ..... 
    ..... 
    ...... 
} 

jour maintenant toile

@Override 
protected void onDraw(Canvas canvas) { 
super.onDraw(canvas); 
canvas.translate(-cam.CameraPos_X,-cam.CameraPos_Y); 
cam.updateCamera(playerX,playerY); 

if(playerX>cam. WorldSize_X) 
    playerX= cam.WorldSize_X; 
else if(playerX<0) 
    playerX=0; 
if(playerY>cam.WorldSize_Y) 
    playerY=cam.WorldSize_Y; 
else if(playerY<0) 
    playerY=0; 
..... 
.... 
//draw bitmap 
    ..... 
} 

Ajouter touchEvents pour contrôler le mouvement de Sprite (http://developer.android.com/reference/android/view/View.html#onTouchEvent(android.view.MotionEvent)

playerY-=5;//move towards up 
playerY+=5;// move towards down 
playerX-=5;// move toward left 
playerX+=5; //move towards right 
+0

Merci beaucoup pour votre aide mais je veux que le personnage fonctionne de gauche à droite et la bordure droite de l'écran mobile ne l'empêche pas de courir et ne rend pas le personnage invisible donc je pense pour faire par exemple le personnage courant avec une vitesse de +10 et la toile elle-même avec la vitesse + 7 (c'est-à-dire: moins que la vitesse du personnage) pour suivre son mouvement et le rendre visible – omar

+0

quand le personnage atteint la bonne bordure il est invisble car il s'exécute en dehors des dimensions de l'écran donc comment traduire les coordonnées de l'écran pour le rendre toujours visible – omar

+0

et aussi toujours courir – omar

0

ok, vous devez traduire toile vers la gauche mais vous déplacez la toile vers la droite.

Prenez une variable moveCanvasX pour traduire la toile vers la gauche. Vous devez également déplacer la toile et l'image-objet au à la même vitesse, déplacez le sprite vers la droite avec la vitesse "xSpeed", déplacez la toile vers la gauche avec la vitesse "xSpeed" afin que l'image-objet reste toujours vers la droite. J'espère que cela résoudra votre problème.

int moveCanvasX=0; 

@Override 
protected void onDraw(Canvas canvas) { 

super.onDraw(canvas); 


if(x>=getWidth()-bmp.getWidth()) 
{ 
    Log.e("cds","cdca"); 
    canvas.translate(-moveCanvasX, 0); 
    moveCanvasX=moveCanvasX+xSpeed; 
    x=x + xSpeed; 
} 
else 
{ 
    x = x + xSpeed; 

} 

if(canvas!=null) { 
    canvas.drawColor(Color.BLACK); 
    canvas.drawBitmap(bmp, x, 10, null); 
} 
} 
+0

je suis extrêmement désolé pour la fin de remerciement vraiment vous remercier pour votre aide, mais cela n'a pas réussi pour moi si j'ai fini par utiliser libgdx et posé cette question http://stackoverflow.com/questions/32595413/libgdx-cant- make-camera-follow-player-not-by-camera-position-nor-unproject peut-être c'est utile pour vous ou toute personne ayant un problème pareil – omar

+0

merci pour le lien –