piecemoveanim.java

手机播放交谈实时监控软件

// Copyright (c) 2005 Sony Ericsson Mobile Communications AB
//
// This software is provided "AS IS," without a warranty of any kind. 
// ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, 
// INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A 
// PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. 
//
// THIS SOFTWARE IS COMPLEMENTARY OF JAYWAY AB (www.jayway.se)

package bluegammon.gui.animation;

import javax.microedition.lcdui.Graphics;

import bluegammon.Audio;
import bluegammon.gui.BoardCanvas;
import bluegammon.gui.Context3D;
import bluegammon.logic.Board;
import bluegammon.logic.BoardMediator;

/**
 * Animation of a piece moving from an source index to a destination index.
 * 
 * @author Peter Andersson
 */
public class PieceMoveAnim extends Animation
{
  protected static int SIZE = 7;
  /** Number of frames in this animation */
  protected int m_frames;
  /** True for white piece, false for black */
  protected boolean m_white;
  /** Piece source position on board */
  protected int m_source;
  /** Piece destination position on board */
  protected int m_dest;
  /** Piece source x coordinate */
  protected int m_x0;
  /** Piece source y coordinate */
  protected int m_y0;
  /** Piece destination x coordinate */
  protected int m_x1;
  /** Piece destination y coordinate */
  protected int m_y1;
  /** How to tilt the piece */
  protected float m_angleSign = 1;
  /** Current frame */
  protected int m_frame = 0;
  /** Current piece coordinates */
  protected float m_x, m_y;
  /** Flag indicating if sinus distortion is applied vertically */
  protected boolean m_vertSin = false;
  /** The factor of the sinus distortion */
  protected float m_sinFact = 0;
  /** The delta of the sinus distortion angle */
  protected float m_sinStep;
  /** Current sinus distortion angle */
  protected float m_sinAngle;
  /** RGB buffer for transparant piece shadow */
  protected static int[] m_shadow;

  /**
   * Initializes this animation with the size of the piece, which is depending
   * on the canvas size.
   * 
   * @param pieceSize  The size of the piece.
   */
  public static void init(int pieceSize)
  {
    SIZE = pieceSize;
    m_shadow = Context3D.createShadowRGB(SIZE, 0);
  }

  /**
   * Creates a new piece movement animation.
   * 
   * @param white   True for white piece, false for black.
   * @param source  Source index of piece.
   * @param dest    Destination index of piece.
   * @param piecesOnSource
   *          Number of pieces on source index.
   * @param piecesOnDest
   *          Number of pieces on destination index.
   */
  public PieceMoveAnim(boolean white, int source, int dest, int piecesOnSource,
      int piecesOnDest)
  {
    BoardCanvas canvas = BoardCanvas.getInstance();

    m_white = white;
    m_source = source;
    m_dest = dest;
    m_angleSign = (source < Board.MAX_POS / 2) ? 1f : -1f;

    // Get source and destination coordinates
    m_x0 = canvas.getPieceX(source, piecesOnSource, white);
    m_y0 = canvas.getPieceY(source, piecesOnSource, white);
    m_x1 = canvas.getPieceX(dest, piecesOnDest, white);
    m_y1 = canvas.getPieceY(dest, piecesOnDest, white);
    m_x = m_x0;
    m_y = m_y0;

    // Calculate number of animation frames for this move
    int dx = Math.abs(m_x1 - m_x0);
    int dy = Math.abs(m_y1 - m_y0);
    m_frames = Math.max(dx, dy);
    m_frames = ((4 * m_frames) / canvas.getHeight());
    m_frames = Math.max(10, m_frames);
    m_frames = Math.min(30, m_frames);
    if (m_dest == Board.POS_GUARD)
    {
      m_frames = 30;
    }

    // Decide if distort vertically or horizontally
    if ((source < 12 && dest < 12) ||
        (source > 11 && dest > 11) || 
        dest == Board.POS_OUT)
    {
      m_vertSin = false;
    } 
    else
    {
      m_vertSin = dy < dx;
    }

    // Calculate parameter for horizontal/vertical move
    if (m_vertSin)
    {
      m_sinFact = (float)canvas.getBoardHeight() / 8f;
    }
    else
    {
      m_sinFact = (float)canvas.getWidth() / 8f;
    }
    if (dest < 12 || (dest == Board.POS_OUT && !white))
      m_sinFact = -m_sinFact;

    // Calculate sinus step
    m_sinStep = (float)Math.PI / (float)(m_frames - 1);
    m_sinAngle = m_sinStep / 2f;
  }

  public void onStart()
  {
    // Remove start piece from canvas, now on move
    BoardCanvas.getInstance().removePiece(m_white, m_source);
  }

  public void paint(Graphics g)
  {
    if (m_frame <= m_frames)
    {
      float frameRatio = (float)m_frame / (float)m_frames;
      float dz = 0f;
      float angle = 0f;
      dz = (float) Math.sin(Math.PI * frameRatio);
      if (m_dest == Board.POS_GUARD)
      {
        // Moving to guard, rotate it
        angle = 540f * frameRatio;
        dz *= 25f;
      }
      else if (m_dest == Board.POS_OUT)
      {
        // Moving out, tilt it so it reaches 60 degrees at end
        angle = (m_white ? -1 : 1) * 60f * frameRatio;
        dz *= 10f;
      }
      else
      {
        // Moving on board, tilt it
        angle = m_angleSign * 75f * (float)Math.sin(Math.PI * frameRatio);
        dz *= 10f;
      }

      // Draw shadow
      Context3D c3d = Context3D.getInstance();
      g.drawRGB(m_shadow, 0, SIZE,
          (int)(m_x - c3d.toScreenCoordinateX(c3d.getShadowProjectionDeltaX(dz),
              BoardCanvas.PIECE_Z)),
          (int)(m_y),
          SIZE, SIZE, true);

      // Draw piece
      BoardCanvas.getInstance().drawPiece(
          (int)m_x, (int)m_y, angle, false, dz, m_white, g);
    }
  }

  public void next()
  {
    // Calculate new piece position
    if (m_frame < m_frames)
    {
      BoardCanvas canvas = BoardCanvas.getInstance();

      // Linear move
      m_x = ((float) (m_x1 - m_x0) * m_frame) / (float) (m_frames) + m_x0;
      m_y = ((float) (m_y1 - m_y0) * m_frame) / (float) (m_frames) + m_y0;

      // Add sinus distortion
      if (m_vertSin)
      {
        m_y -= (m_sinFact * Math.sin(m_sinAngle));
      }
      else
      {
        m_x -= (m_sinFact * Math.sin(m_sinAngle));
      }
      m_sinAngle += m_sinStep;

      // Repaint
      canvas.requestRepaint();
    }
    m_frame++;
  }

  public boolean isFinished()
  {
    return m_frame >= m_frames;
  }

  public void onExit()
  {
    BoardCanvas canvas = BoardCanvas.getInstance();
    // Add end piece on canvas, now static
    canvas.addPiece(m_white, m_dest);
    canvas.requestRepaint();
    if (!BoardMediator.isGameFinished())
      Audio.playSound(Audio.PIECE);
  }

  public long getInterval()
  {
    return 20;
  }
}