cursoranim.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.gui.BoardCanvas;
import bluegammon.logic.Board;
import bluegammon.logic.BoardMediator;

/**
 * Animation of the cursors indicating the source and destination index of a
 * possible movement.
 * 
 * @author Peter Andersson
 */
public class CursorAnim extends Animation
{
  protected static final int SOURCE_COL = 0x22ffff;
  protected static final int DEST_COL = 0xffff22;
  protected static int m_cursorSize;
  protected int m_sx, m_sy,
  				m_dx, m_dy,
  				m_csx, m_cdx,
  				m_xAdjustS, m_xAdjustD,
  				m_frame;

  protected boolean m_sourceLeft, m_destLeft;
  protected volatile boolean m_stopped;

  /**
   * Initializes this animation with the size of the cursor, depending on the
   * canvas size of this device.
   * 
   * @param cursorSize The size of the cursor.
   */
  public static void init(int cursorSize)
  {
    m_cursorSize = cursorSize;
  }

  /**
   * Creates a new cursor animation indicating where user moves a piece from and
   * where the piece will end up.
   * 
   * @param source   Source index of piece.
   * @param dest     Destination index of piece.
   * @param bxOnSrc  Number of pieces on source row.
   * @param bxOnDst  Number of pieces on destination row.
   * @param white    True for white player, false for black.
   */
  public CursorAnim(int source, int dest, int bxOnSrc, int bxOnDst,
      boolean white)
  {
    BoardCanvas canvas = BoardCanvas.getInstance();

    int srcPieceCount = Math.min(5, bxOnSrc);
    int dstPieceCount = Math.min(5, bxOnDst);
    srcPieceCount = Math.max(srcPieceCount, 1);

    if (bxOnSrc > 4)
      m_xAdjustS = -m_cursorSize;
    if (bxOnDst > 4)
      m_xAdjustD = m_cursorSize;

    // Get source and destination coordinates for cursors
    m_sx = canvas.getPieceX(source, srcPieceCount, white);
    m_sy = canvas.getPieceY(source, srcPieceCount, white);
    m_dx = canvas.getPieceX(dest, dstPieceCount, white);
    m_dy = canvas.getPieceY(dest, dstPieceCount, white);

    if (source <= Board.POS_BOARD)
    {
      m_sourceLeft = source > 11;
    }
    else if (source == Board.POS_GUARD)
    {
      m_sourceLeft = white;
    }

    if (dest <= Board.POS_BOARD)
    {
      m_destLeft = dest < 12;
    }
    else if (dest == Board.POS_OUT)
    {
      m_destLeft = !white;
    }
  }

  public void paint(Graphics g)
  {
    if (!m_stopped)
    {
      g.setColor(SOURCE_COL);
      m_csx = m_sx;
      if (m_sourceLeft)
        m_csx += m_xAdjustS + m_frame;
      else
        m_csx -= m_xAdjustS + m_frame;
      drawArrow(g, m_csx, m_sy, m_sourceLeft);
      g.setColor(DEST_COL);
      m_cdx = m_dx;
      if (m_destLeft)
        m_cdx += m_xAdjustD + m_frame;
      else
        m_cdx -= m_xAdjustD + m_frame;
      drawArrow(g, m_cdx, m_dy, m_destLeft);
    }
  }

  /**
   * Draws an arrow used for cursor
   * 
   * @param g    Graphics context to draw to.
   * @param x    X coordinate of arrow.
   * @param y    Y coordinate of arrow.
   * @param left True for left pointing arrow, false for right.
   */
  protected void drawArrow(Graphics g, int x, int y, boolean left)
  {
    int w = 3;
    int h = m_cursorSize / 2;
    if (left)
    {
      for (int dy = 0; dy < h; dy++)
        g.drawLine(x + (h - dy), y + dy, x + (h - dy) + w, y + dy);
      for (int dy = h; dy <= (h << 1); dy++)
        g.drawLine(x + (dy - h), y + dy, x + (dy - h) + w, y + dy);
    }
    else
    {
      for (int dy = 0; dy < h; dy++)
        g.drawLine(x + dy, y + dy, x + dy + w, y + dy);
      for (int dy = h; dy <= (h << 1); dy++)
        g.drawLine(x + ((h << 1) - dy), y + dy,
            	   x + ((h << 1) - dy) + w, y + dy);
    }
  }

  public void next()
  {
    m_frame = (m_frame - 1) & 3;
    BoardCanvas.getInstance().requestRepaint();
  }

  public boolean isFinished()
  {
    return m_stopped || BoardMediator.isGameFinished()
        || !BoardCanvas.getInstance().isUserMovable();
  }

  public long getInterval()
  {
    return 200;
  }

  /**
   * Stops this cursor animation.
   */
  public void stop()
  {
    m_stopped = true;
  }
}