Bug em jogo de Natal

Mobile
#1

Resumo da ópera: Gostaria de saber como faço para numa tela TouchScrean ter o mesmo efeito de segurar a tecla do teclado. No código abaixo qndo eu seguro a tecla o boneco anda certinho, já qndo eu clico eu tenho que ficar clicando feito um maníaco pro boneco andar =/. Obrigado!

Olá a todos :smiley:
Estou meio por fora em java, faz 1 ano e meio que não programo com frequencia porque aqui na empresa me colcoaram na área de BI.
Estou retomando aos poucos e como tinha que fazer um presente de natal pra minha namorada, resolvi fazer um joguinho em J2ME e assim mato dois coelhos com uma cajadada.
(sim, eu nem sabia q ela curtia essas coisas… e ela não fazia ideia que eu mexia com isso :P).

A questão é que neste joguinho eu uso touchscreen e tá dando um bug nervoso… qndo eu clico no botão das setas o boneco começa a andar e não para. Eu queria um comportamento parecido com o que acontece com as teclas do teclado, que funcionam normalmente.

A ideia é: O boneco anda ENQUANTO se pressiona um botão virtual na tela
OU o boneco mantém a última direção até que o botão PARAR seja clicado. Qualquer uma das situações resolve o meu problema, mas como estou enferrujado devo estar comendo bola e errando no óbvio. Valeu galera, Feliz Natal :wink:

Acho que o erro está neste metodo. Depois dele eu coloquei a classe NatalCanvas inteira

[code] public void onButtomTouch(ImageButtom buttom) {
while (!this.interrupted) {
if (buttom == botaoDireita) {
// //Cria o alerta de mensagem
// Alert alert = new Alert("Tocado no botão.");
// //Mostra a mensagem na tela
// Display.getDisplay(GameMidlet.a).setCurrent(alert, this);
//tratamento para botão direito
if (this.lastDirection != RIGHT) {
this.lastDirection = RIGHT;
if(missoes[1]==false){
this.spriteSte.setFrameSequence(gameDesign.SteDireita);
}
if (missoes[1] == true) {
this.spriteSte.setFrameSequence(gameDesign.SteDireitaG);

                }
               continue;
            }

            this.spriteSteAnimator.forward();
            this.spriteSte.move(SPEED, 0);
            if (this.spriteSteCollides(this.spriteSte)) {
                this.spriteSte.move(-SPEED, 0);
            //this.spriteHyo.setFrameSequence(gameDesign.HyoEsquerda);
               continue;
            }
            this.adjustViewport(this.viewPortX + SPEED, this.viewPortY);
   
   } else if (buttom == botaoEsquerda) {

        if (this.lastDirection != LEFT) {
                this.lastDirection = LEFT;
               //coloca para a esqueda

                if(missoes[1]==false){
                   this.spriteSte.setFrameSequence(gameDesign.SteEsquerda);}
                if(missoes[1]==true){
               this.spriteSte.setFrameSequence(gameDesign.SteEsquerdaG);
               }
             continue;
            }
            //roda o filminho de andar a esquerda
            this.spriteSteAnimator.forward();
            //move efetivamente(desloca) o boneco para a esquerda
            this.spriteSte.move(-SPEED, 0);
            //se ele bater em alguma coisa, faz ele voltar para onde estava(antes de ir pra esquerda)
            if (this.spriteSteCollides(this.spriteSte)) {
                this.spriteSte.move(SPEED, 0);
              continue;
            }

            //ajusta a visão do usuário para manter o bonequinho na tela
            this.adjustViewport(this.viewPortX - SPEED, this.viewPortY);
    }else if(buttom == botaoCima){
       if (this.lastDirection != UP) {
                this.lastDirection = UP;
                 if(missoes[1]==false){
                this.spriteSte.setFrameSequence(gameDesign.SteCostas);
              //  this.spriteHyo.setFrameSequence(gameDesign.HyoEsquerda);
                 }
                if (missoes[1] == true) {
               this.spriteSte.setFrameSequence(gameDesign.SteCostasG);
               }

                continue;
            }
            this.spriteSteAnimator.forward();
            this.spriteSte.move(0, -SPEED);
            if (this.spriteSteCollides(this.spriteSte)) {
                this.spriteSte.move(0, SPEED);
              continue;
            }}

else if (buttom == botaoBaixo){
//tratamento para baixo
if (this.lastDirection != DOWN) {
this.lastDirection = DOWN;
// this.spriteSte.setFrameSequence(gameDesign.SteFrente);
if(missoes[1]==false){
this.spriteSte.setFrameSequence(gameDesign.SteFrente);
}
if(missoes[1]==true){
this.spriteSte.setFrameSequence(gameDesign.SteFrenteG);
}
continue;

       }
            this.spriteSteAnimator.forward();
            this.spriteSte.move(0, SPEED);
            if (this.spriteSteCollides(this.spriteSte)) {
                this.spriteSte.move(0, -SPEED);
                continue;
            }
            this.adjustViewport(this.viewPortX, this.viewPortY + SPEED);

}
else if(buttom == botaoParar){
this.spriteSteAnimator.setMoving(false);

}
try{Thread.sleep(50);}catch(Exception e){}
}
//this.spriteSteAnimator.setMoving(false);

}
[/code]


/**
 *
 * @author  Du
 * @version 1.0
 */
//define classe principal
public  class NatalCanvas extends GameCanvas implements ButtomListener,Runnable {

     public ImageButtom botaoDireita, botaoEsquerda,botaoCima,botaoBaixo,botaoParar;

    private static final int SPEED = 3;
    private static final int MIN_BUFFER = 10;
    private int viewPortX = 0;
    private int viewPortY = 0;
    private byte lastDirection = -1;
    private TiledLayer tlBase;
    private boolean interrupted;
    public LayerManager lm;
     public LayerManager lm2;
    private GameDesign gameDesign;
    private Timer timer;
    public Sprite spriteSte;
    private SpriteAnimationTask spriteSteAnimator;
  public boolean[] missoes = {false,false,true,false,false,false,false,false,false,false,false};
    public Sprite spritePai;
    private SpriteAnimationTask spritePaiAnimator;
    private SpriteRandomMovement spritePaiRandomMovement;
  private Sprite spriteBuddy;
    private SpriteAnimationTask spriteBuddyAnimator;
  private Sprite spriteHyo;
  private Sprite spriteVo;
  private SpriteAnimationTask spriteVoAnimator;
private Sprite spriteMae;
  private SpriteAnimationTask spriteMaeAnimator;

  private Sprite spriteAranha;
    private SpriteAnimationTask spriteHyoAnimator;
    private Sprite falaHyo;
public Sprite falaBuddy;
public Sprite falaPai;
public Sprite PortaHospital;

private SpriteRandomMovementBuddy spriteBuddyRandomMovement;
   // private SpriteRandomMovementHyo spriteHyoRandomMovement;
    //  private TiledLayer tlWater;
   // private TiledLayer tlTrees;
    private TiledLayer tlHospital;
    private TiledLayer tlArvores;
private TiledLayer tlFloresta;
    //    private TileAnimationTask waterAnimator;

    //construtor
    public NatalCanvas() {
        super(true);
        try {
                    int corVermelha = 0x00ff0000;

        //Define a fonte que será usada no label dos botões
        Font fonteBotao = Font.getFont(Font.FACE_PROPORTIONAL, Font.STYLE_BOLD, Font.SIZE_LARGE);

        //Define a imagem que será usada no fundo dos botões
        Image imagemCima = getImagemBotao("cima.png");
Image imagemBaixo = getImagemBotao("baixo.png");
Image imagemEsquerda = getImagemBotao("esquerda.png");
Image imagemDireita = getImagemBotao("direita.png");
Image imagemParar = getImagemBotao("parar.png");





        //Instancia o botão passando o X, Y, a imagem que ele deve mostrar,
        //e o listener que executará o evento touch do botão. O Listener é a
        //própria classe dessa tela, pois ela está implementando a interface que
        //criamos para disparar os eventos, chamada ButtomListener. (x,y)
//botaoEsquerda.listener.onButtomTouch(botaoEsquerda);
        botaoEsquerda = new ImageButtom(0, 30, imagemEsquerda, this, "", corVermelha, fonteBotao);
        botaoParar = new ImageButtom(30, 30, imagemParar,this , "", corVermelha, fonteBotao);

        botaoDireita = new ImageButtom(60, 30, imagemDireita, this, "", corVermelha, fonteBotao);
        botaoCima = new ImageButtom(30, 0, imagemCima, this, "", corVermelha, fonteBotao);
        botaoBaixo = new ImageButtom(30, 60, imagemBaixo, this, "", corVermelha, fonteBotao);
            this.setFullScreenMode(true);
            this.init();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    /**
    Pega todos as camadas e inicializa o design do jogo
     */
    private void init() throws IOException {

        this.timer = new Timer();
        this.gameDesign = new GameDesign();
//desenha o personagem principal
        this.spriteSte = gameDesign.getSpriteSte();
        //A referência do personagem será um ponto, referenciado a seguir.(baricentro)
        this.spriteSte.defineReferencePixel(8, 8);
        this.spriteSteAnimator = new SpriteAnimationTask(this.spriteSte, false);
// um controlador para o andar do personagem principal
        this.timer.scheduleAtFixedRate(this.spriteSteAnimator, 0, gameDesign.SteFrenteDelay);

        this.PortaHospital = gameDesign.getEntrarHospital();
        //A referência do personagem será um ponto, referenciado a seguir.(baricentro)
        this.PortaHospital.defineReferencePixel(8, 8);
//        this.spriteSteAnimator = new SpriteAnimationTask(this.spriteSte, false);
//// um controlador para o andar do personagem principal
//        this.timer.scheduleAtFixedRate(this.spriteSteAnimator, 0, gameDesign.SteFrenteDelay);

//animações para cenário
//        this.waterAnimator = new TileAnimationTask(gameDesign.getWater(), gameDesign.AnimWaterWater, gameDesign.AnimWaterSeq001, true);
//        this.timer.scheduleAtFixedRate(this.waterAnimator, 0, gameDesign.AnimWaterSeq001Delay);

//pega as camadas e instancia-as
        this.tlHospital = this.gameDesign.getHospital();
        this.tlArvores = this.gameDesign.getArvores();
        this.tlFloresta = this.gameDesign.getFloresta();

        this.tlBase = this.gameDesign.getBase();
//define gerenciador de camadas
        this.lm = new LayerManager();
        gameDesign.updateLayerManagerForHospitalFora(lm);
        //gameDesign.updateLayerManagerForHospitalRecepcao(lm);
   this.falaHyo = gameDesign.getFalaHyo();
this.falaBuddy = gameDesign.getFalaBuddy();
this.falaPai = gameDesign.getPaiFala();

        //gameDesign.updateLayerManagerForHospitalRecepcao(lm);
        //           this.lm = new LayerManager();
//            gameDesign.updateLayerManagerForHospitalFora(lm);

       // gameDesign.updateLayerManagerForHospitalFora(lm);
//define NPCs. Usaremos aqui a família da Sté
        //cria Pai
        this.spritePai = gameDesign.getSpritePai();
//        //Baricentro, como dito acima
        this.spritePai.defineReferencePixel(8, 8);
        this.spritePaiAnimator = new SpriteAnimationTask(this.spritePai, true);
//        //método para movimentação das imagens
        //this.spritePaiAnimator.setMoving(true);
//        //controlador de tempo para mudar as posições das imagens enquanto anda
        this.timer.scheduleAtFixedRate(this.spritePaiAnimator, 0, gameDesign.PaiCostasDelay);
//        //define movimento aleatório para NPC
        this.spritePaiRandomMovement = new SpriteRandomMovement(this, spritePai);
//        //descreve como será o andar do personagem
        this.spritePaiRandomMovement.setSequences(
            gameDesign.PaiFrente, Sprite.TRANS_NONE,
            gameDesign.PaiCostas, Sprite.TRANS_NONE,
            gameDesign.PaiEsquerda, Sprite.TRANS_NONE,
            gameDesign.PaiDireita, Sprite.TRANS_NONE
            );
        (new Thread(spritePaiRandomMovement)).start();
//

      
        //cria Buddy
        this.spriteBuddy = gameDesign.getSpriteBuddy();
//        //Baricentro, como dito acima
        this.spriteBuddy.defineReferencePixel(8, 8);
        this.spriteBuddyAnimator = new SpriteAnimationTask(this.spriteBuddy, true);
//        //método para movimentação das imagens
        this.spriteBuddyAnimator.setMoving(true);
//        //controlador de tempo para mudar as posições das imagens enquanto anda
        this.timer.scheduleAtFixedRate(this.spriteBuddyAnimator, 0, gameDesign.BuddyCostasDelay);
//        //define movimento aleatório para NPC
        this.spriteBuddyRandomMovement = new SpriteRandomMovementBuddy(this, spriteBuddy,spriteSte);
//        //descreve como será o andar do personagem
        this.spriteBuddyRandomMovement.setSequences(
            gameDesign.BuddyFrente, Sprite.TRANS_NONE,
            gameDesign.BuddyCostas, Sprite.TRANS_NONE,
            gameDesign.BuddyEsquerda, Sprite.TRANS_NONE,
            gameDesign.BuddyDireita, Sprite.TRANS_NONE
            );
        (new Thread(spriteBuddyRandomMovement)).start();
 
//         this.spriteMae = gameDesign.getSpriteHyo();
//        //A referência do personagem será um ponto, referenciado a seguir.(baricentro)
//        this.spriteHyo.defineReferencePixel(8, 8);
//        this.spriteHyoAnimator = new SpriteAnimationTask(this.spriteHyo, false);
//// um controlador para o andar do personagem principal
//        this.timer.scheduleAtFixedRate(this.spriteHyoAnimator, 0, gameDesign.HyoFrenteDelay);
///

  this.spriteHyo = gameDesign.getSpriteHyo();
        //A referência do personagem será um ponto, referenciado a seguir.(baricentro)
        this.spriteHyo.defineReferencePixel(8, 8);
        this.spriteHyoAnimator = new SpriteAnimationTask(this.spriteHyo, false);
// um controlador para o andar do personagem principal
        this.timer.scheduleAtFixedRate(this.spriteHyoAnimator, 0, gameDesign.HyoFrenteDelay);
//      this.spriteHyoRandomMovement = new SpriteRandomMovementHyo(this, spriteHyo,falaHyo);
////        //descreve como será o andar do personagem
//        this.spriteHyoRandomMovement.setSequences(
//            gameDesign.HyoFrente, Sprite.TRANS_NONE,
//            gameDesign.HyoCostas, Sprite.TRANS_NONE,
//            gameDesign.HyoEsquerda, Sprite.TRANS_NONE,
//            gameDesign.HyoDireita, Sprite.TRANS_NONE
//            );
//        (new Thread(spriteHyoRandomMovement)).start();
//this.spriteVo = gameDesign.getVo()
  //  this.spriteVo = gameDesign.

    }
    /**
     verifica colisão
     */
    //fazer método de colisão para cada personagem
    public boolean spriteSteCollides(Sprite sprite) {
        return sprite.collidesWith(this.tlHospital, true)
        //  || sprite.collidesWith(  sprite == this.spriteSte ? this.spritePai : this.spriteSte, true)
           // || sprite.collidesWith(this.spritePai, true)
            || sprite.collidesWith(this.spriteBuddy, true)
            //|| sprite.collidesWith(this.tlTrees, true)
            //|| sprite.collidesWith(this.tlWater, true)
            || sprite.collidesWith(this.tlArvores, true)
            || sprite.collidesWith(this.tlFloresta, true)
|| sprite.collidesWith(this.spriteHyo, true)
|| sprite.collidesWith(this.spritePai, true)
            || sprite.getX() < 0 || sprite.getY() < 0 
            || sprite.getX() > (this.tlBase.getWidth() - sprite.getWidth()) 
            || sprite.getY() > (this.tlBase.getHeight() - sprite.getHeight()

            );
    }
        public boolean spriteHyoCollides(Sprite sprite) {
        return sprite.collidesWith(this.spriteHyo, true);


    }
         public boolean spritePaiCollides(Sprite sprite) {
        return sprite.collidesWith(this.spritePai, true);


    }
        public boolean spritePortaHospitalCollides(Sprite sprite) {
        return sprite.collidesWith(this.PortaHospital, true);



    }

    public boolean spriteCollides(Sprite sprite) {
        return sprite.collidesWith(this.tlHospital, true)
       //   || sprite.collidesWith(  sprite == this.spriteSte ? this.spritePai : this.spriteSte, true)
            || sprite.collidesWith(this.spriteSte, true)
//            || sprite.collidesWith(this.spriteHyo, true)

            || sprite.collidesWith(this.spriteBuddy, true)
            || sprite.collidesWith(this.tlArvores, true)

            //|| sprite.collidesWith(this.tlTrees, true)
            //|| sprite.collidesWith(this.tlWater, true)
            || sprite.getX() < 0 || sprite.getY() < 0
            || sprite.getX() > (this.tlBase.getWidth() - sprite.getWidth())
            || sprite.getY() > (this.tlBase.getHeight() - sprite.getHeight()
            );
    }
//    public void HyoFala01(Sprite sprite){
//this.spriteHyo.setFrameSequence(gameDesign.flHyo01);
//        if(missoes[2]==false){
//    missoes[2]=true;
//     this.falaHyo.setFrame(2);
//}

    //}
     public boolean spriteBuddyCollides(Sprite sprite) {
        return sprite.collidesWith(this.tlHospital, true)
       //   || sprite.collidesWith(  sprite == this.spriteSte ? this.spritePai : this.spriteSte, true)
            || sprite.collidesWith(this.spriteSte, true)
         //   || sprite.collidesWith(this.spritePai, true)
            || sprite.collidesWith(this.tlArvores, true)
    || sprite.collidesWith(this.tlFloresta, true)

            //|| sprite.collidesWith(this.tlWater, true)
            || sprite.getX() < 0 || sprite.getY() < 0
            || sprite.getX() > (this.tlBase.getWidth() - sprite.getWidth())
            || sprite.getY() > (this.tlBase.getHeight() - sprite.getHeight()

            );
    }
//      public boolean spriteCollides(Sprite sprite) {
//        return sprite.collidesWith(this.tlHospital, true)
//          //  sprite == this.spriteKarel ? this.spriteThomas : this.spriteKarel, true)
//            || sprite.collidesWith(this.spriteSte, true)
//            //|| sprite.collidesWith(this.tlTrees, true)
//            //|| sprite.collidesWith(this.tlWater, true)
//            || sprite.getX() < 0 || sprite.getY() < 0
//            || sprite.getX() > (this.tlBase.getWidth() - sprite.getWidth())
//            || sprite.getY() > (this.tlBase.getHeight() - sprite.getHeight()
//            );
//    }

    /**
    Ajusta a visão na tela
     *
     */
    private void adjustViewport(int x, int y) {

        int sx = this.spriteSte.getX();
        int sy = this.spriteSte.getY();

        int xmin = this.viewPortX ;
        int xmax = this.viewPortX + this.getWidth() - this.spriteSte.getWidth();
        int ymin = this.viewPortY;
        int ymax = this.viewPortY + this.getHeight() - this.spriteSte.getHeight();

        //não ajustar caso o personagem não esteja nas bordas
        if (sx >= xmin && sx <= xmax && sy >= ymin && sy <= ymax) {
            return;
        }

        //não ajustar caso o personagem não esteja nas bordas(ESQUERDA)
        if (this.lastDirection == LEFT && sx >= xmin) {
            return;
        }
        //não ajustar caso o personagem não esteja nas bordas(DIREITA)
        if (this.lastDirection == RIGHT && sx <= xmax) {
            return;
        }
        ////não ajustar caso o personagem não esteja nas bordas(CIMA)
        if (this.lastDirection == UP && sy >= ymin) {
            return;
        }
        ////não ajustar caso o personagem não esteja nas bordas(BAIXO)
        if (this.lastDirection == DOWN && sy <= ymax) {
            return;
        }

        //só ajustar x se tiver blocos disponíveis
        if (x < this.tlBase.getX()) {
            this.viewPortX = this.tlBase.getX();
        } else if (x > this.tlBase.getX() + this.tlBase.getWidth() - this.getWidth()) {
            this.viewPortX = this.tlBase.getX() + this.tlBase.getWidth() - this.getWidth();
        } else {
            this.viewPortX = x;
        }

        //só ajustar y se tiver blocos disponiveis
        if (y < this.tlBase.getY()) {
            this.viewPortY = this.tlBase.getY();
        } else if (y > this.tlBase.getY() + this.tlBase.getHeight() - this.getHeight()) {
            this.viewPortY = this.tlBase.getY() + this.tlBase.getHeight() - this.getHeight();
        } else {
            this.viewPortY = y;
        }

        //ajustar
        this.lm.setViewWindow(this.viewPortX, this.viewPortY, this.getWidth(), this.getHeight());
    }

    /**
     * Funcionamento base do jogo. Espera uma entrada do usuário e joga na tela as atualizações
     */
    public void run() {
        Graphics g = getGraphics();

        while (!this.interrupted) {
            //pega entrada do usuário
//     if(this.spriteHyoCollides(this.spriteSte)){
//     this.spriteHyo.setFrameSequence(gameDesign.HyoEsquerda);
//
//     }
              if(this.spriteHyoCollides(this.spriteSte)){
                  missoes[2]=true;
                  if(missoes[4]==true){
                          this.falaHyo.setFrameSequence(gameDesign.Hyofl03);
                            this.falaBuddy.setFrameSequence(gameDesign.Buddyfl01);
                  }else if(missoes[2]==true){
                     
                       this.falaHyo.setFrameSequence(gameDesign.Hyofl02);
                    
}
            }
               if(this.spritePaiCollides(this.spriteSte)){
                  missoes[5]=true;
                  if(missoes[6]==true){
                         this.falaPai.setFrameSequence(gameDesign.Paifl02);
                  }else if(missoes[5]==true){

                       this.falaPai.setFrameSequence(gameDesign.Paifl01);

}
            }

              if(this.spritePortaHospitalCollides(this.spriteSte)){
                  missoes[5]=true;
                  if(missoes[5]==true){
             //  this.lm = new LayerManager();
                    
                      //  gameDesign.updateLayerManagerForHospitalRecepcao(this.lm);
                    
                  }else if(missoes[2]==true){

                       this.falaHyo.setFrameSequence(gameDesign.Hyofl02);

}
            }
            int keyState = getKeyStates();
          //  int keyState = this.get
if ((keyState & this.FIRE_PRESSED) != 0) {
   // this.spriteHyo.setFrameSequence(gameDesign.fHyo01);
  if (missoes[1]==false){ missoes[1]=true;}
 else{missoes[1]=false;}
}
  

            //this.spriteHyo.setFrameSequence(gameDesign.flHyo01);
            //se o botão esquerdo for pressionado
            if ((keyState & LEFT_PRESSED) != 0) {
                //Se a direção anterior não for esquerda, então precisa colocar o bonequinho para
                //a esquerda
                if (this.lastDirection != LEFT) {
                    this.lastDirection = LEFT;
                   //coloca para a esqueda
                   
                    if(missoes[1]==false){
                       this.spriteSte.setFrameSequence(gameDesign.SteEsquerda);}
                    if(missoes[1]==true){
                   this.spriteSte.setFrameSequence(gameDesign.SteEsquerdaG);
                   }
                   continue;
                }
                //roda o filminho de andar a esquerda
                this.spriteSteAnimator.forward();
                //move efetivamente(desloca) o boneco para a esquerda
                this.spriteSte.move(-SPEED, 0);
                //se ele bater em alguma coisa, faz ele voltar para onde estava(antes de ir pra esquerda)
                if (this.spriteSteCollides(this.spriteSte)) {
                    this.spriteSte.move(SPEED, 0);
                    continue;
                }
//                if(this.spriteHyoCollides(this.spriteHyo)){
//     this.falaHyo.setFrameSequence(gameDesign.flHyo01);
//    // this.falaHyo.setTransform(1);
//                }
//                if(this.spriteHyoCollides(this.spriteHyo)){
//                if(missoes[2]==false){
//                missoes[2]=true;
//                }else{
//                }
//                }
                //ajusta a visão do usuário para manter o bonequinho na tela
                this.adjustViewport(this.viewPortX - SPEED, this.viewPortY);
            } else if ((keyState & RIGHT_PRESSED) != 0) {
                //tratamento para botão direito
                if (this.lastDirection != RIGHT) {
                    this.lastDirection = RIGHT;
                    if(missoes[1]==false){
                    this.spriteSte.setFrameSequence(gameDesign.SteDireita);
                    }
                    if (missoes[1] == true) {
                   this.spriteSte.setFrameSequence(gameDesign.SteDireitaG);
                   }
                   continue;
                }
                    
                this.spriteSteAnimator.forward();
                this.spriteSte.move(SPEED, 0);
                if (this.spriteSteCollides(this.spriteSte)) {
                    this.spriteSte.move(-SPEED, 0);
                //this.spriteHyo.setFrameSequence(gameDesign.HyoEsquerda);
                    continue;
                }
                this.adjustViewport(this.viewPortX + SPEED, this.viewPortY);
            } else if ((keyState & UP_PRESSED) != 0) {
                if (this.lastDirection != UP) {
                    this.lastDirection = UP;
                     if(missoes[1]==false){
                    this.spriteSte.setFrameSequence(gameDesign.SteCostas);
                  //  this.spriteHyo.setFrameSequence(gameDesign.HyoEsquerda);
                     }
                    if (missoes[1] == true) {
                   this.spriteSte.setFrameSequence(gameDesign.SteCostasG);
                   }
                    
                    continue;
                }
                this.spriteSteAnimator.forward();
                this.spriteSte.move(0, -SPEED);
                if (this.spriteSteCollides(this.spriteSte)) {
                    this.spriteSte.move(0, SPEED);
                    continue;
                }
                this.adjustViewport(this.viewPortX, this.viewPortY - SPEED);
            } else if ((keyState & DOWN_PRESSED) != 0) {
                //tratamento para baixo
                if (this.lastDirection != DOWN) {
                    this.lastDirection = DOWN;
                  //  this.spriteSte.setFrameSequence(gameDesign.SteFrente);
                     if(missoes[1]==false){
                    this.spriteSte.setFrameSequence(gameDesign.SteFrente);
                    }
                    if(missoes[1]==true){
                   this.spriteSte.setFrameSequence(gameDesign.SteFrenteG);
                   }
                    continue;
                }
                this.spriteSteAnimator.forward();
                this.spriteSte.move(0, SPEED);
                if (this.spriteSteCollides(this.spriteSte)) {
                    this.spriteSte.move(0, -SPEED);
                    continue;
                }
                this.adjustViewport(this.viewPortX, this.viewPortY + SPEED);
            } else {
                //se não apertou nenhuma tecla, não deixar o personagem andar.
                this.spriteSteAnimator.setMoving(false);
            }

            this.lm.paint(g, 0, 0);
            //pinta na tela
//             g.setColor(0x00dddddd);
//        g.fillRect(0, 0, getWidth(), getHeight());
//        g.setColor(0x00ff0000);
//        g.setFont(Font.getFont(Font.FACE_PROPORTIONAL, Font.STYLE_BOLD, Font.SIZE_LARGE));
//        g.drawString("Exemplo de botão", 10, 10, 0);

        //Pede aos botões para eles se pintarem no Graphics da tela
        botaoEsquerda.paint(g);
        botaoDireita.paint(g);

                botaoCima.paint(g);
        botaoBaixo.paint(g);
        botaoParar.paint(g);

            flushGraphics(0, 0, this.getWidth(), this.getHeight());
//joga o resultado no display
            try {
                Thread.sleep(20);
                //unidade de tempo 20ms
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }

    /**
     * Controle de Pause
     */
    public void stop() {
        this.interrupted = true;
       // this.spriteThomasRandomMovement.stop();
    }
protected void pointerPressed(int x, int y){
     if (botaoDireita.isTouched(x, y))
            return;

        if (botaoEsquerda.isTouched(x, y))
            return;

     if (botaoCima.isTouched(x, y))
            return;

     if (botaoBaixo.isTouched(x, y))
            return;

         if (botaoParar.isTouched(x, y))
            return;

    }



//
//
//public void onButttomTouch(Sprite sprite){
//if(sprite == spriteHyo){
//                  missoes[2]=true;
//                  if(missoes[4]==true){
//                          this.falaHyo.setFrameSequence(gameDesign.Hyofl03);
//                            this.falaBuddy.setFrameSequence(gameDesign.Buddyfl01);
//                  }else if(missoes[2]==true){
//
//                       this.falaHyo.setFrameSequence(gameDesign.Hyofl02);
//
//}
//
//}
//}
   public void onButtomTouch(ImageButtom buttom) {
     while (!this.interrupted) {
       if (buttom == botaoDireita) {
//            //Cria o alerta de mensagem
//            Alert alert = new Alert("Tocado no botão.");
//            //Mostra a mensagem na tela
//            Display.getDisplay(GameMidlet.a).setCurrent(alert, this);
            //tratamento para botão direito
                if (this.lastDirection != RIGHT) {
                    this.lastDirection = RIGHT;
                    if(missoes[1]==false){
                    this.spriteSte.setFrameSequence(gameDesign.SteDireita);
                    }
                    if (missoes[1] == true) {
                   this.spriteSte.setFrameSequence(gameDesign.SteDireitaG);

                    }
                   continue;
                }

                this.spriteSteAnimator.forward();
                this.spriteSte.move(SPEED, 0);
                if (this.spriteSteCollides(this.spriteSte)) {
                    this.spriteSte.move(-SPEED, 0);
                //this.spriteHyo.setFrameSequence(gameDesign.HyoEsquerda);
                   continue;
                }
                this.adjustViewport(this.viewPortX + SPEED, this.viewPortY);
       
       } else if (buttom == botaoEsquerda) {

            if (this.lastDirection != LEFT) {
                    this.lastDirection = LEFT;
                   //coloca para a esqueda

                    if(missoes[1]==false){
                       this.spriteSte.setFrameSequence(gameDesign.SteEsquerda);}
                    if(missoes[1]==true){
                   this.spriteSte.setFrameSequence(gameDesign.SteEsquerdaG);
                   }
                 continue;
                }
                //roda o filminho de andar a esquerda
                this.spriteSteAnimator.forward();
                //move efetivamente(desloca) o boneco para a esquerda
                this.spriteSte.move(-SPEED, 0);
                //se ele bater em alguma coisa, faz ele voltar para onde estava(antes de ir pra esquerda)
                if (this.spriteSteCollides(this.spriteSte)) {
                    this.spriteSte.move(SPEED, 0);
                  continue;
                }

                //ajusta a visão do usuário para manter o bonequinho na tela
                this.adjustViewport(this.viewPortX - SPEED, this.viewPortY);
        }else if(buttom == botaoCima){
           if (this.lastDirection != UP) {
                    this.lastDirection = UP;
                     if(missoes[1]==false){
                    this.spriteSte.setFrameSequence(gameDesign.SteCostas);
                  //  this.spriteHyo.setFrameSequence(gameDesign.HyoEsquerda);
                     }
                    if (missoes[1] == true) {
                   this.spriteSte.setFrameSequence(gameDesign.SteCostasG);
                   }

                    continue;
                }
                this.spriteSteAnimator.forward();
                this.spriteSte.move(0, -SPEED);
                if (this.spriteSteCollides(this.spriteSte)) {
                    this.spriteSte.move(0, SPEED);
                  continue;
                }}
 else if (buttom == botaoBaixo){
  //tratamento para baixo
                if (this.lastDirection != DOWN) {
                    this.lastDirection = DOWN;
                  //  this.spriteSte.setFrameSequence(gameDesign.SteFrente);
                     if(missoes[1]==false){
                    this.spriteSte.setFrameSequence(gameDesign.SteFrente);
                    }
                    if(missoes[1]==true){
                   this.spriteSte.setFrameSequence(gameDesign.SteFrenteG);
                   }
                    continue;
                    
           }
                this.spriteSteAnimator.forward();
                this.spriteSte.move(0, SPEED);
                if (this.spriteSteCollides(this.spriteSte)) {
                    this.spriteSte.move(0, -SPEED);
                    continue;
                }
                this.adjustViewport(this.viewPortX, this.viewPortY + SPEED);
 }
 else if(buttom == botaoParar){
   this.spriteSteAnimator.setMoving(false);

 
   }
       try{Thread.sleep(50);}catch(Exception e){}
            }
    //this.spriteSteAnimator.setMoving(false);
            
   }
       private Image getImagemBotao(String caminho) {
        try {
            return Image.createImage(caminho);
        } catch (IOException ex) {
            return null;
        }
    }
/**
     * Gerencia anima~~oes
     */

    private class TileAnimationTask extends TimerTask {

        private boolean moving = true;
        private boolean forward = true;
        private TiledLayer tiledLayer;
        private int animatedTileIndex;
        private int[] sequence;
        private int sequenceIndex;

        public TileAnimationTask(TiledLayer tiledLayer, int animatedTileIndex, int[] sequence, boolean forward) {
            this.tiledLayer = tiledLayer;
            this.animatedTileIndex = animatedTileIndex;
            this.sequence = sequence;
            this.forward = forward;
        }

        public void run() {
            if (!this.moving) {
                return;
            }
            if (forward) {
                if (++this.sequenceIndex >= this.sequence.length) {
                    sequenceIndex = 0;
                }
            } else {
                if (--this.sequenceIndex < 0) {
                    sequenceIndex = this.sequence.length - 1;
                }
            }
            this.tiledLayer.setAnimatedTile(this.animatedTileIndex, this.sequence[sequenceIndex]);
        }

        public void forward() {
            this.forward = true;
            this.moving = true;
        }

        public void backward() {
            this.forward = false;
            this.moving = true;
        }

        public void setMoving(boolean isMoving) {
            this.moving = isMoving;
        }
    }

/**
     * Gerencia animação de bonequinhos
     */
    private class SpriteAnimationTask extends TimerTask {

        private boolean moving = false;
        private boolean forward = true;
        private Sprite sprite;

        public SpriteAnimationTask(Sprite sprite, boolean forward) {
            this.sprite = sprite;
            this.forward = forward;
        }

        public void run() {
            if (!this.moving) {
                return;
            }
            if (this.forward) {
                this.sprite.nextFrame();
            } else {
                this.sprite.prevFrame();
            }
        }

        public void forward() {
            this.forward = true;
            this.moving = true;
        }

        public void backward() {
            this.forward = false;
            this.moving = true;
        }

        public void setMoving(boolean isMoving) {
            this.moving = isMoving;
        }
//         protected void paint(Graphics g) {
//        //Pinta a tela Canvas normalmente
////        g.setColor(0x00dddddd);
////        g.fillRect(0, 0, getWidth(), getHeight());
////        g.setColor(0x00ff0000);
////        g.setFont(Font.getFont(Font.FACE_PROPORTIONAL, Font.STYLE_BOLD, Font.SIZE_LARGE));
////        g.drawString("Exemplo de botão", 10, 10, 0);
//
//        //Pede aos botões para eles se pintarem no Graphics da tela
//        botaoEsquerda.paint(g);
//        botaoDireita.paint(g);
//     botaoCima.paint(g);
//        botaoBaixo.paint(g);
//        botaoParar.paint(g);
//         }

    }
}
#2

só pra constar, quando eu terminar eu disponibilizo o projeto aqui como de costume pra galera que quiser aprender a fazer jogos ter um referencial :wink:

#3

avanços:
coloquei uma variavel booleana que trava a execução. Eu ativo ela quando o toca na tela e desativo quando ele anda. Assim ele anda normal, só que tem q dar 300 cliques pro boneco andar direito =/…vou tentar uma maneira de “segurar” o boneco andando

#4