コード例 #1
0
    public void clearAll() {
      this.setVisible(false);
      ACTION = ACTION_DEFAULT;
      this.unregisterUpdateHandler(timerHandler);
      mCubicStartAniSprite.clearEntityModifiers();
      mCubicStartAniSprite.clearUpdateHandlers();
      mCubicStartAniSprite.stopAnimation(0);
      mCubicStartAniSprite.setVisible(false);

      mCubicTurnAniSprite.clearEntityModifiers();
      mCubicTurnAniSprite.clearUpdateHandlers();
      mCubicTurnAniSprite.stopAnimation(0);
      mCubicTurnAniSprite.setVisible(false);

      mCubicStopAniSprite.clearEntityModifiers();
      mCubicStopAniSprite.clearUpdateHandlers();
      mCubicStopAniSprite.stopAnimation(0);
      mCubicStopAniSprite.setVisible(false);

      mScrollLeftSprite.clearEntityModifiers();
      mScrollLeftSprite.setVisible(false);

      for (int i = 0; i < mCubicTurnOptionAniSprite.length; i++) {
        mCubicTurnOptionAniSprite[i].setVisible(false);
        mCubicTurnOptionAniSprite[i].clearEntityModifiers();
        mCubicTurnOptionAniSprite[i].clearUpdateHandlers();
        mCubicTurnOptionAniSprite[i].stopAnimation();
      }

      removePhysics(this);
    }
コード例 #2
0
    public CubicEntity(
        float pX,
        float pY,
        int pCubic,
        final ITiledTextureRegion pCubicStart,
        final ITiledTextureRegion pCubicTurn,
        final ITiledTextureRegion pCubicStop,
        final ITiledTextureRegion pCubicTurnOption[],
        ITextureRegion pTextureRegion) {
      super(pX, pY, pTextureRegion, mVertexBufferObjectManager);
      setAlpha(0.0f);
      TYPE = pCubic;
      mCubicStartAniSprite = new AnimatedSprite(0, 0, pCubicStart, mVertexBufferObjectManager);
      this.attachChild(mCubicStartAniSprite);
      mCubicStartAniSprite.setVisible(false);

      float turnX = getWidth() - pCubicTurn.getWidth();
      float turnY = getHeight() - pCubicTurn.getHeight();
      mCubicTurnAniSprite =
          new AnimatedSprite(turnX - 15, turnY - 15, pCubicTurn, mVertexBufferObjectManager);
      this.attachChild(mCubicTurnAniSprite);
      mCubicTurnAniSprite.setVisible(false);

      for (int i = 0; i < mCubicTurnOptionAniSprite.length; i++) {
        float turnOpX = getWidth() - pCubicTurnOption[i].getWidth();
        float turnOpY = getHeight() - pCubicTurnOption[i].getHeight();
        mCubicTurnOptionAniSprite[i] =
            new AnimatedSprite(turnOpX, turnOpY, pCubicTurnOption[i], mVertexBufferObjectManager);
        this.attachChild(mCubicTurnOptionAniSprite[i]);
        mCubicTurnOptionAniSprite[i].setVisible(false);
      }

      float stopX = getWidth() - pCubicTurn.getWidth();
      float stopY = getHeight() - pCubicTurn.getHeight();
      mCubicStopAniSprite =
          new AnimatedSprite(stopX - 15, stopY - 15, pCubicStop, mVertexBufferObjectManager);
      this.attachChild(mCubicStopAniSprite);
      mCubicStopAniSprite.setVisible(false);

      float scrollX = turnX + pCubicTurn.getWidth() / 2 - mScrollLeftTextureRegion.getWidth();
      float scrollY = turnY + pCubicTurn.getHeight() - mScrollLeftTextureRegion.getHeight();
      mScrollLeftSprite =
          new Sprite(scrollX, scrollY, mScrollLeftTextureRegion, mVertexBufferObjectManager);
      this.attachChild(mScrollLeftSprite);
      mScrollLeftSprite.setVisible(false);

      mScrollLeftSprite.registerEntityModifier(
          new LoopEntityModifier(
              new SequenceEntityModifier(
                  new AlphaModifier(0.5f, 0.2f, 1.0f), new AlphaModifier(0.5f, 1.0f, 0.2f))));
    }
コード例 #3
0
  // ===========================================================
  // Methods
  // ===========================================================
  private void addMario(final float pX, final float pY) {
    final Body body;

    final FixtureDef objectFixtureDef = PhysicsFactory.createFixtureDef(1, 0.5f, 0.5f);

    mario =
        new AnimatedSprite(pX, pY, this.mMarioTextureRegion, this.getVertexBufferObjectManager());
    mario.animate(new long[] {100, 100, 100}, 3, 5, true);
    body =
        PhysicsFactory.createBoxBody(
            this.mPhysicsWorld, mario, BodyType.DynamicBody, objectFixtureDef);

    marioRight =
        new AnimatedSprite(pX, pY, this.mMarioTextureRegion, this.getVertexBufferObjectManager());
    marioRight.animate(new long[] {100, 100, 100}, 3, 5, true);
    // bodyRight = PhysicsFactory.createBoxBody(this.mPhysicsWorld, marioRight,
    // BodyType.DynamicBody, objectFixtureDef);

    marioLeft =
        new AnimatedSprite(pX, pY, this.mMarioTextureRegion, this.getVertexBufferObjectManager());
    marioLeft.animate(new long[] {100, 100, 100}, 0, 2, true);
    // bodyLeft = PhysicsFactory.createBoxBody(this.mPhysicsWorld, marioLeft, BodyType.DynamicBody,
    // objectFixtureDef);

    // marioJump = new AnimatedSprite(pX, pY, this.mMarioJumpTextureRegion,
    // this.getVertexBufferObjectManager());
    // marioJump.animate(new long[] { 100, 1000 }, 0, 1, true);

    this.mPhysicsWorld.registerPhysicsConnector(new PhysicsConnector(mario, body, true, true));
    this.mPhysicsWorld.registerPhysicsConnector(new PhysicsConnector(marioRight, body, true, true));
    this.mPhysicsWorld.registerPhysicsConnector(new PhysicsConnector(marioLeft, body, true, true));
    // this.mPhysicsWorld.registerPhysicsConnector(new PhysicsConnector(marioJump, body, true,
    // true));

    mario.setUserData(body);
    this.mScene.attachChild(mario);

    marioRight.setUserData(body);
    this.mScene.attachChild(marioRight);

    marioLeft.setUserData(body);
    this.mScene.attachChild(marioLeft);

    // marioJump.setUserData(body);
    // this.mScene.attachChild(marioJump);

    marioRight.setVisible(false);
    marioLeft.setVisible(false);
    // marioJump.setVisible(false);
  }
コード例 #4
0
    private void action(int action) {
      mCubicStartAniSprite.setVisible(false);
      mCubicStartAniSprite.stopAnimation(0);
      switch (action) {
        case ACTION_TURN_LEVEL_1:
        case ACTION_TURN_LEVEL_2:
        case ACTION_TURN_LEVEL_3:
          ACTION = action;
          final Body body = (Body) this.getUserData();
          final Vector2 vector2 = Vector2Pool.obtain(body.getPosition());
          int frame[] = new int[] {0, 1};
          body.setAngularDamping(1.2f);
          vector2.x = vector2.x / 3;
          vector2.y = vector2.y / 3;
          if (action == ACTION_TURN_LEVEL_2) {
            frame = new int[] {2, 3};
            body.setAngularDamping(2.2f);
            vector2.x = vector2.x / 2;
            vector2.y = vector2.y / 2;
          } else if (action == ACTION_TURN_LEVEL_3) {
            frame = new int[] {4, 5};
            body.setAngularDamping(3.2f);
          }
          Vol3Osyougatsu.OGG_A3_A_5_KOMATEI.play();
          mCubicTurnAniSprite.animate(new long[] {250, 250}, frame, -1);
          mCubicTurnAniSprite.setVisible(true);

          body.setActive(true);
          Log.i(TAG, "body.getPosition " + vector2);
          vector2.x = random(vector2.x) + new Random().nextFloat();
          vector2.y = random(vector2.y) + new Random().nextFloat();
          body.setLinearVelocity(vector2);
          Log.i(TAG, "body.getPosition change " + vector2);
          this.unregisterUpdateHandler(timerHandler);
          this.registerUpdateHandler(
              timerHandler =
                  new TimerHandler(
                      6f,
                      new ITimerCallback() {

                        @Override
                        public void onTimePassed(TimerHandler timerHandler) {
                          // Stop Turn
                          stopTurn();
                        }
                      }));
          break;
      }
    }
コード例 #5
0
  @Override
  public void onPauseGame() {
    if (!isDrawView || !isPreView) {
      return;
    }
    Log.i(TAG, "-- onPauseGame --");
    this.unregisterUpdateHandler(updateHandler);
    CUBIC_SLOT[0] = false;
    CUBIC_SLOT[1] = false;
    mArrowSprite.setVisible(false);
    mSuzuAniSprite.stopAnimation(0);
    mShishiAniSprite.stopAnimation();
    mShishiAniSprite.clearEntityModifiers();
    mShishiAniSprite.resetLocalToFirst();
    mShishiAniSprite.setVisible(false);

    for (int i = 0; i < mCubicEntity.length; i++) {
      if (mCubicEntity[i] != null) {
        mCubicEntity[i].clearAll();
      }
    }

    if (faceSequenceEntityModifier != null) {
      this.unregisterEntityModifier(faceSequenceEntityModifier);
      faceSequenceEntityModifier = null;
    }

    for (int i = 1; i < mTabSprite.length; i++) {
      mTabSprite[i].setVisible(false);
    }
  }
コード例 #6
0
 private void handAction(int pAction) {
   setVisibleHandDefault(false);
   switch (pAction) {
     case 2: // Door Human
       mHandActionAniSprite.setCurrentTileIndex(3);
       mHandActionAniSprite.setVisible(true);
       break;
     case 1: // Door ani
     case 0:
       mHandActionAniSprite.setCurrentTileIndex(4);
       mHandActionAniSprite.setVisible(true);
       break;
     case 3:
       mHandActionAniSprite.setCurrentTileIndex(5);
       mHandActionAniSprite.setVisible(true);
       break;
   }
 }
コード例 #7
0
  @Override
  public void onAccelerometerChanged(final AccelerometerData pAccelerometerData) {
    this.mGravityX = pAccelerometerData.getX();
    this.mGravityY = pAccelerometerData.getY();

    if (pAccelerometerData.getX() > 0) {
      marioMoveRight = true;
      marioMoveLeft = false;
      marioStand = false;
    } else if (pAccelerometerData.getX() == 0) {
      marioMoveLeft = false;
      marioMoveRight = false;
      marioStand = true;
    } else if (pAccelerometerData.getX() < 0) {
      marioStand = false;
      marioMoveLeft = true;
      marioMoveRight = false;
    }

    float bufX = mario.getX();
    float bufY = mario.getY();

    if (marioMoveLeft && mario != marioLeft) {
      mario.setVisible(false);
      mario = marioLeft;
    } else if (marioMoveRight && mario != marioRight) {
      mario.setVisible(false);
      mario = marioRight;
    } else if (marioStand) {
      mario.setVisible(false);
    }
    mario.setPosition(bufX, bufY);
    mario.setVisible(true);

    final Vector2 gravity = Vector2Pool.obtain(this.mGravityX * 5, this.mGravityY);
    this.mPhysicsWorld.setGravity(gravity);
    Vector2Pool.recycle(gravity);
  }
コード例 #8
0
    // Function Stop Turn when out time and collision "shishi"
    public void stopTurn() {
      Vol3Osyougatsu.OGG_A3_A_5_KOMATEI.stop();
      ACTION = ACTION_TURN_STOP;
      for (int i = 0; i < mCubicTurnOptionAniSprite.length; i++) {
        mCubicTurnOptionAniSprite[i].stopAnimation();
        mCubicTurnOptionAniSprite[i].setVisible(false);
      }
      mCubicTurnAniSprite.stopAnimation(0);
      mCubicTurnAniSprite.setVisible(false);
      removePhysics(CubicEntity.this);
      mCubicStopAniSprite.animate(
          new long[] {200, 1000},
          new int[] {0, 1},
          0,
          new IAnimationListener() {

            @Override
            public void onAnimationStarted(AnimatedSprite arg0, int arg1) {
              mCubicStopAniSprite.setVisible(true);
            }

            @Override
            public void onAnimationLoopFinished(AnimatedSprite arg0, int arg1, int arg2) {}

            @Override
            public void onAnimationFrameChanged(AnimatedSprite arg0, int arg1, int arg2) {
              Log.i("XXX", arg1 + " Changed ID : " + arg2);
              int index = arg2;
              if (index == -1) {
                index = 0;
              }
              if (index >= 2) return;
              float width = mCubicStopAniSprite.getTiledTextureRegion().getWidth(index);
              float height = mCubicStopAniSprite.getTiledTextureRegion().getHeight(index);
              Log.i("XXX", width + " ~ " + height);
              mCubicStopAniSprite.setWidth(width);
              mCubicStopAniSprite.setHeight(height);
            }

            @Override
            public void onAnimationFinished(AnimatedSprite arg0) {
              CubicEntity.this.clearAll();
              mCubicChooseSpite[CubicEntity.this.TYPE].setVisible(true);
              CUBIC_SLOT[SLOT] = false;
              checkArrow();
            }
          });
    }
コード例 #9
0
    private void touchToTurn(final int pAction) {
      Vol3Osyougatsu.OGG_A3_A_5_SPACE6.play();
      final int ran = new Random().nextInt(mCubicTurnOptionAniSprite.length);
      if (ran == 0) {
        ACTION = ACTION_TURN_GIRL;
      } else if (ran == 1) {
        ACTION = ACTION_TURN_BOY;
      } else if (ran == 2) {
        ACTION = ACTION_TURN_FUNGI;
      }
      mCubicTurnAniSprite.stopAnimation();
      mCubicTurnAniSprite.setVisible(false);
      mCubicTurnOptionAniSprite[ran].animate(
          new long[] {250, 250},
          new int[] {0, 1},
          2,
          new IAnimationListener() {

            @Override
            public void onAnimationStarted(AnimatedSprite arg0, int arg1) {
              mCubicTurnOptionAniSprite[ran].setVisible(true);
            }

            @Override
            public void onAnimationLoopFinished(AnimatedSprite arg0, int arg1, int arg2) {}

            @Override
            public void onAnimationFrameChanged(AnimatedSprite arg0, int arg1, int arg2) {}

            @Override
            public void onAnimationFinished(AnimatedSprite arg0) {
              mCubicTurnOptionAniSprite[ran].setVisible(false);
              mCubicTurnOptionAniSprite[ran].stopAnimation();
              ACTION = pAction;
              int frame[] = new int[] {0, 1};
              if (ACTION == ACTION_TURN_LEVEL_2) {
                frame = new int[] {2, 3};
              } else if (ACTION == ACTION_TURN_LEVEL_3) {
                frame = new int[] {4, 5};
              }
              // run back...
              mCubicTurnAniSprite.animate(new long[] {250, 250}, frame, -1);
              mCubicTurnAniSprite.setVisible(true);
            }
          });
    }
コード例 #10
0
 public void newEvent(float pX, float pY, int pSlot) {
   mCubicChooseSpite[TYPE].setVisible(false);
   SLOT = pSlot;
   CUBIC_SLOT[SLOT] = true;
   checkArrow();
   this.setPosition(0, 100);
   ACTION = ACTION_DEFAULT;
   mCubicStartAniSprite.setVisible(true);
   mScrollLeftSprite.clearEntityModifiers();
   mScrollLeftSprite.registerEntityModifier(
       new LoopEntityModifier(
           new SequenceEntityModifier(
               new AlphaModifier(0.5f, 0.2f, 1.0f), new AlphaModifier(0.5f, 1.0f, 0.2f))));
   mScrollLeftSprite.setVisible(true);
   this.setVisible(true);
   final Body body = (Body) CubicEntity.this.getUserData();
   Vector2 vector2 =
       Vector2Pool.obtain(
           pX / PhysicsConstants.PIXEL_TO_METER_RATIO_DEFAULT,
           pY / PhysicsConstants.PIXEL_TO_METER_RATIO_DEFAULT);
   body.setTransform(vector2, 0);
   Vector2Pool.recycle(vector2);
 }
コード例 #11
0
 private void handDefault() {
   setVisibleHandDefault(true);
   mHandActionAniSprite.setVisible(false);
   isHand = true;
   resetBaby();
 }
コード例 #12
0
  @Override
  protected void loadKaraokeScene() {
    this.mScene = new Scene();
    this.mScene.setOnAreaTouchTraversalFrontToBack();
    this.mScene.setTouchAreaBindingOnActionDownEnabled(true);
    this.mScene.setTouchAreaBindingOnActionMoveEnabled(true);
    this.mScene.setOnSceneTouchListener(this);
    this.mScene.setBackground(
        new SpriteBackground(
            new Sprite(0, 0, mHaikeiTextureRegion, this.getVertexBufferObjectManager())));

    mKaigaAnimatedSprite =
        new AnimatedSprite(162, 37, mKaigaTiledTextureRegion, this.getVertexBufferObjectManager());
    this.mScene.attachChild(mKaigaAnimatedSprite);

    mTvAnimatedSprite =
        new AnimatedSprite(56, 226, mTvTiledTextureRegion, this.getVertexBufferObjectManager());
    this.mScene.attachChild(mTvAnimatedSprite);

    mClockAnimatedSprite =
        new AnimatedSprite(616, 22, mClockTiledTextureRegion, this.getVertexBufferObjectManager());
    this.mScene.attachChild(mClockAnimatedSprite);
    mClockAnimatedSprite.animate(new long[] {500, 500}, new int[] {0, 1}, -1);

    mClockCandyLeftSprite =
        new Sprite(575, -100, mClockCandyLeftTextureRegion, this.getVertexBufferObjectManager());
    this.mScene.attachChild(mClockCandyLeftSprite);

    mDoorAnimatedSprite =
        new AnimatedSprite(696, 168, mDoorTiledTextureRegion, this.getVertexBufferObjectManager());
    this.mScene.attachChild(mDoorAnimatedSprite);
    mDoorAnimatedSprite.setCurrentTileIndex(0);

    mClockCandyRightSprite =
        new Sprite(660, -95, mClockCandyRightTextureRegion, this.getVertexBufferObjectManager());
    this.mScene.attachChild(mClockCandyRightSprite);
    mClockCandyLeftSprite.setVisible(false);
    mClockCandyRightSprite.setVisible(false);

    mSofaSprite = new Sprite(0, 0, mSofaTextureRegion, this.getVertexBufferObjectManager());
    this.mScene.attachChild(mSofaSprite);

    mHandActionAniSprite =
        new AnimatedSprite(
            156, 71, mHandActionTiledTextureRegion, this.getVertexBufferObjectManager());
    this.mScene.attachChild(mHandActionAniSprite);
    mHandActionAniSprite.setVisible(false);

    mHandDefaultSprite =
        new Sprite(156, 71, mHandDefaultTextureRegion, this.getVertexBufferObjectManager());
    this.mScene.attachChild(mHandDefaultSprite);

    final int FingerPoint[][] = new int[][] {{0, 114}, {57, 57}, {171, 0}, {284, 0}, {397, 114}};

    for (int i = 0; i < 5; i++) {
      mFingerAnimatedSprite[i] =
          new FringerAnimatedSprite(
              156 + FingerPoint[i][0],
              71 + FingerPoint[i][1],
              mFingerTiledTextureRegion[i],
              this.getVertexBufferObjectManager());
      this.mScene.attachChild(mFingerAnimatedSprite[i]);
      this.mScene.registerTouchArea(mFingerAnimatedSprite[i]);
      mFingerAnimatedSprite[i].setCurrentTileIndex(0);
      mFingerAnimatedSprite[i].idIndex = i;
    }

    mCryLeftSprite =
        new Sprite(584, 310, mCryLeftTextureRegion, this.getVertexBufferObjectManager());
    this.mScene.attachChild(mCryLeftSprite);
    mCryLeftSprite.setBlendFunction(GL10.GL_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA);
    mCryLeftSprite.setVisible(false);

    mCryRightSprite =
        new Sprite(690, 335, mCryRightTextureRegion, this.getVertexBufferObjectManager());
    this.mScene.attachChild(mCryRightSprite);
    // mCryRightSprite.setRotation(-90);
    mCryRightSprite.setBlendFunction(GL10.GL_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA);
    mCryRightSprite.setVisible(false);

    mMilkSprite = new MilkSprite(mMilkTextureRegion, this.getVertexBufferObjectManager());
    this.mScene.attachChild(mMilkSprite);
    this.mScene.registerTouchArea(mMilkSprite);
    mMilkSprite.setVisible(false);

    addGimmicsButton(
        mScene,
        Vol3OhanashiResouce.SOUND_GIMMIC,
        new int[] {
          Vol3OhanashiResouce.main.A19_OHANASHI_1_IPHONE_ID,
          Vol3OhanashiResouce.main.A19_OHANASHI_2_IPHONE_ID,
          Vol3OhanashiResouce.main.A19_OHANASHI_3_IPHONE_ID
        },
        mMainTexturePackLibs);
  }
コード例 #13
0
  protected void drawScene() {
    Log.i(TAG, "----------drawScene------------------------------");

    this.mPhysicsWorld = new PhysicsWorld(new Vector2(0, 0), false);
    this.registerUpdateHandler(mPhysicsWorld);
    this.mPhysicsWorld.setContactListener(contactListener);

    final Sprite spriteBackGround =
        new Sprite(
            960 / 2 - mBackGroundTextureRegion.getWidth() / 2,
            0,
            mBackGroundTextureRegion,
            mVertexBufferObjectManager);
    this.attachChild(spriteBackGround);

    for (int i = 0; i < mTabSprite.length; i++) {
      mTabSprite[i] =
          new Sprite(
              960 / 2 - 1150 / 2,
              89.5f,
              tpTab[i].getTexturePackTextureRegionLibrary().get(0),
              mVertexBufferObjectManager);
      this.attachChild(mTabSprite[i]);
      mTabSprite[i].setVisible(false);
    }
    mTabSprite[0].setVisible(true);

    final Body body =
        this.physicsEditorShapeLibrary.createBody(
            "a3_5_1_iphone_dai", mTabSprite[0], this.mPhysicsWorld);
    this.mPhysicsWorld.registerPhysicsConnector(
        new PhysicsConnector(mTabSprite[0], body, true, true));
    mTabSprite[0].setUserData(body);

    // Cubic Choose
    mCubicChooseSpite[CUBIC_YELLOW] =
        new Sprite(
            279,
            70,
            tpOne
                .getTexturePackTextureRegionLibrary()
                .get(Vol3OsyougatsuResource.packer_parta_1.A3_6_4_IPHONE_KOMA_ID),
            mVertexBufferObjectManager);
    this.attachChild(mCubicChooseSpite[CUBIC_YELLOW]);

    mCubicChooseSpite[CUBIC_GREEN] =
        new Sprite(
            200,
            90f,
            tpOne
                .getTexturePackTextureRegionLibrary()
                .get(Vol3OsyougatsuResource.packer_parta_1.A3_6_3_IPHONE_KOMA_ID),
            mVertexBufferObjectManager);
    this.attachChild(mCubicChooseSpite[CUBIC_GREEN]);

    mCubicChooseSpite[CUBIC_BLUE] =
        new Sprite(
            110,
            107,
            tpOne
                .getTexturePackTextureRegionLibrary()
                .get(Vol3OsyougatsuResource.packer_parta_1.A3_6_2_IPHONE_KOMA_ID),
            mVertexBufferObjectManager);
    this.attachChild(mCubicChooseSpite[CUBIC_BLUE]);

    mCubicChooseSpite[CUBIC_ORANGE] =
        new Sprite(
            22f,
            135,
            tpOne
                .getTexturePackTextureRegionLibrary()
                .get(Vol3OsyougatsuResource.packer_parta_1.A3_6_1_IPHONE_KOMA_ID),
            mVertexBufferObjectManager);
    this.attachChild(mCubicChooseSpite[CUBIC_ORANGE]);

    cubicTouch = new CubicTouch(0, 0, 960, 640, null);
    this.attachChild(cubicTouch);
    this.registerTouchArea(cubicTouch);

    for (int i = CUBIC_ORANGE; i <= CUBIC_YELLOW; i++) {
      final TextureRegion iOTextureRegion =
          new TextureRegion(
              bitmapTexture[i % 2],
              2,
              2,
              mCubicStartTiledTexture[i].getWidth(),
              mCubicStartTiledTexture[i].getHeight());
      mCubicEntity[i] =
          new CubicEntity(
              0,
              100,
              i,
              mCubicStartTiledTexture[i],
              mCubicTurnTiledTexture[i],
              mCubicStopTiledTexture[i],
              mCubicTurnOptionTiledTexture,
              iOTextureRegion);
      this.attachChild(mCubicEntity[i]);
      mCubicEntity[i].setVisible(false);
      // Body
      final Body bodyCubic =
          this.physicsEditorShapeLibrary.createBody(
              CUBIC_BODYNAME[i], mCubicEntity[i], this.mPhysicsWorld);
      bodyCubic.setFixedRotation(true);
      bodyCubic.setActive(false);
      mCubicEntity[i].setUserData(bodyCubic);
      mPhysicsWorld.registerPhysicsConnector(
          new PhysicsConnector(mCubicEntity[i], bodyCubic, true, true));
    }

    final SceneTouch sceneTouch = new SceneTouch(0, 0, 960, 640, null);
    this.attachChild(sceneTouch);
    this.registerTouchArea(sceneTouch);

    mSuzuAniSprite =
        new AnimatedSprite(
            960 / 2 - mSuzuTiledTexTure.getWidth() / 2,
            -19,
            mSuzuTiledTexTure,
            mVertexBufferObjectManager);
    this.attachChild(mSuzuAniSprite);

    mShishiAniSprite =
        new AnimatedSprite(960, 59.5f, mShishiTiledTexTure, mVertexBufferObjectManager);
    this.attachChild(mShishiAniSprite);
    mShishiAniSprite.setVisible(false);

    mArrowSprite =
        new Sprite(
            120,
            133,
            tpThree
                .getTexturePackTextureRegionLibrary()
                .get(Vol3OsyougatsuResource.packer_parta_3.A3_8_1_IPHONE_YAJIRUSHI_ID),
            mVertexBufferObjectManager);
    this.attachChild(mArrowSprite);
    mArrowSprite.setVisible(false);
  }