AndEngine 애니메이션을 작성하고 점수를 한 번 계산 한 다음 무시합니다.

Question

AndEngine과 거의 경쟁하고 있습니다. 유일한 문제는 연락처에서 스프라이트에 애니메이션을 적용하고 점수를 한 번 계산 한 다음 추가 업데이트를 무시하는 것입니다. 내 플레이어 엔티티가 객체에 접촉하면 AndEngine에 점수를 매기고 애니메이션을 적용 할 수 있지만 객체가 접촉하지 않을 때까지 계속 계산됩니다. 이 문제는 setIgnoreUpdates()로 수정되었지만 객체를 애니메이션으로 만들지는 않습니다. 어떤 아이디어가 이것을 고치는 방법?

이 지금까지 내 코드입니다 : 내가 다른 수정에서 어둠 속에서 자상으로 animateCrate() 메소드를 추가 한

private int score = 0; 

AnimatedSprite wooden_crate = new AnimatedSprite(0, 0, resourceManager.wooden_crate_region, vbom); 
private void animateCrate() 
{ 
    final long[] CRATE_ANIMATE = new long[] {0, 25, 25, 25, 25, 15000}; 
    wooden_crate.animate(CRATE_ANIMATE, 0, 5, true); 
} 
private void addToScore(int i) 
{ 
    score += i; 
    scoreText.setText("Score: " + score); 
} 

private PhysicsWorld physicsWorld; 

private void createPhysics() 
{ 
    physicsWorld = new FixedStepPhysicsWorld(60, new Vector2(0, -24), false); 
    physicsWorld.setContactListener(contactListener()); 
    registerUpdateHandler(physicsWorld); 
} 

private static final String TAG_ENTITY = "entity"; 
private static final String TAG_ENTITY_ATTRIBUTE_X = "x"; 
private static final String TAG_ENTITY_ATTRIBUTE_Y = "y"; 
private static final String TAG_ENTITY_ATTRIBUTE_TYPE = "type"; 

private static final Object TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_FLOOR = "floor"; 
private static final Object TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_PLAYER = "player"; 
private static final Object TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_STEEL_CRATE = "steelCrate"; 
private static final Object TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_WOODEN_CRATE = "woodenCrate"; 

private Player player; 

private void loadLevel(int levelID) 
{ 
    final SimpleLevelLoader levelLoader = new SimpleLevelLoader(vbom); 

    final FixtureDef FIXTURE_DEF = PhysicsFactory.createFixtureDef(0, 0.01f, 0.5f); 

    levelLoader.registerEntityLoader(new EntityLoader<SimpleLevelEntityLoaderData>(LevelConstants.TAG_LEVEL) 
    { 
     public IEntity onLoadEntity(final String pEntityName, final IEntity pParent, final Attributes pAttributes, final SimpleLevelEntityLoaderData pSimpleLevelEntityLoaderData) throws IOException 
     { 
      final int width = SAXUtils.getIntAttributeOrThrow(pAttributes, LevelConstants.TAG_LEVEL_ATTRIBUTE_WIDTH); 
      final int height = SAXUtils.getIntAttributeOrThrow(pAttributes, LevelConstants.TAG_LEVEL_ATTRIBUTE_HEIGHT); 

      // TODO later we will specify camera BOUNDS and create invisible walls 
      // on the beginning and on the end of the level. 
      camera.setBounds(0, 0, width, height); // here we set camera bounds 
      camera.setBoundsEnabled(true); 

      return GameScene.this; 
     } 
    }); 

    levelLoader.registerEntityLoader(new EntityLoader<SimpleLevelEntityLoaderData>(TAG_ENTITY) 
    { 
     public IEntity onLoadEntity(final String pEntityName, final IEntity pParent, final Attributes pAttributes, final SimpleLevelEntityLoaderData pSimpleLevelEntityLoaderData) throws IOException 
     { 
      final int x = SAXUtils.getIntAttributeOrThrow(pAttributes, TAG_ENTITY_ATTRIBUTE_X); 
      final int y = SAXUtils.getIntAttributeOrThrow(pAttributes, TAG_ENTITY_ATTRIBUTE_Y); 
      final String type = SAXUtils.getAttributeOrThrow(pAttributes, TAG_ENTITY_ATTRIBUTE_TYPE); 

      final Sprite levelObject; 

      if (type.equals(TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_FLOOR)) 
      { 
       levelObject = new Sprite(x, y, resourceManager.platform1_region, vbom); 
       PhysicsFactory.createBoxBody(physicsWorld, levelObject, BodyType.StaticBody, FIXTURE_DEF).setUserData("floor"); 
      } 
      else if (type.equals(TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_STEEL_CRATE)) 
      { 
       levelObject = new Sprite(x, y, resourceManager.steel_crate_region, vbom); 
       PhysicsFactory.createBoxBody(physicsWorld, levelObject, BodyType.StaticBody, FIXTURE_DEF).setUserData("steelCrate"); 
      } 
      else if (type.equals(TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_WOODEN_CRATE)) 
      { 
       levelObject = new AnimatedSprite(x, y, resourceManager.wooden_crate_region, vbom) 
       { 
        @Override 
        protected void onManagedUpdate(float pSecondsElapsed) 
        { 
         super.onManagedUpdate(pSecondsElapsed); 

         if (player.collidesWith(this)) 
         { 
          addToScore(1); 
          animateCrate(); 
          setIgnoreUpdate(true); 

       };}}; 
      } 
      else if (type.equals(TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_PLAYER)) 
      { 
       player = new Player(x, y, vbom, camera, physicsWorld) 
       {      
        @Override 
        public void onDie() 
        { 
         // TODO Latter we will handle it. 
         if (!gameOverDisplayed) 
         { 
          displayGameOverText(); 
          this.setIgnoreUpdate(true); 
         } 
        } 
       }; 
       levelObject = player; 
      } 
      else 
      { 
       throw new IllegalArgumentException(); 
      } 

      levelObject.setCullingEnabled(true); 

      return levelObject; 
     } 
    }); 

    levelLoader.loadLevelFromAsset(activity.getAssets(), "level/" + levelID + ".lvl"); 
} 
private boolean firstTouch = false; 

public boolean onSceneTouchEvent(Scene pScene, TouchEvent pSceneTouchEvent) 
{ 
    if (pSceneTouchEvent.isActionDown()) 
    { 
     if (!firstTouch) 
     { 
      player.setRunning(); 
      firstTouch = true; 
     } 
     else 
     { 
      player.jump(); 
     } 
    } 
    return false; 
} 
private ContactListener contactListener() 
{ 
    ContactListener contactListener = new ContactListener() 
    { 
     public void beginContact(Contact contact) 
     { 
      final Fixture x1 = contact.getFixtureA(); 
      final Fixture x2 = contact.getFixtureB(); 

      if (x1.getBody().getUserData() != null && x2.getBody().getUserData() != null) 
      { 
       if (x2.getBody().getUserData().equals("player")) 
       { 
        player.increaseFootContacts(); 
       } 
      } 
     } 

     public void endContact(Contact contact) 
     { 
      final Fixture x1 = contact.getFixtureA(); 
      final Fixture x2 = contact.getFixtureB(); 

      if (x1.getBody().getUserData() != null && x2.getBody().getUserData() != null) 
      { 
       if (x2.getBody().getUserData().equals("player")) 
       { 
        player.decreaseFootContacts(); 
       } 
       if (x1.getBody().getUserData().equals("steelCrate") && x2.getBody().getUserData().equals("player")) 
       { 
        player.onDie(); 
       } 
      } 
     } 

     public void preSolve(Contact contact, Manifold oldManifold) 
     { 

     } 

     public void postSolve(Contact contact, ContactImpulse impulse) 
     { 

     } 
    }; 
    return contactListener; 
} 

참고. 애니메이션을 무시하고 점수를 계산합니다.

첫 번째 대답에서 예제를 구현하려고했지만 위의 코드가 확실하지 않습니다.

Answer 1

해결 방법 : 접촉이 완료되었을 때 설정되고 접촉이 완료되면 재설정되는 부울 플래그가 있어야합니다. 이 같은 뭔가 :

public class MyContactListener implements ContactListener { 
    boolean mContactFlag; 
    public MyContactListener() { 
     mContactFlag = false; 
    } 

    @Override 
    public void beginContact(Contact arg0) { 
     if (mContactFlag){ 
      // Don't animate... 
     } 
     else{ 
      // Animate and add score... 
      mContactFlag = true; 
     } 
    } 

    @Override 
    public void endContact(Contact arg0) { 
     mContactFlag = false; // Reset the flag here   
    } 

    @Override 
    public void postSolve(Contact arg0, ContactImpulse arg1) {} 

    @Override 
    public void preSolve(Contact arg0, Manifold arg1) {} 
}