node.java

java learn PPT java learn PPT java learn PPT java learn PPT

     import java.awt.*;
     import java.awt.geom.*;
     
     import magic.graphics.*;

     public class Node extends magic.actor2d.Actor2D 
     {
          // 移动节点的目标vector 
          private Vector2D dest;

          // 动画的当前索引
          private int animIndex;

          // 节点在线路中的索引
          private int circuitIndex;

          // 节点的目标或者目的索引
          private int circuitIndexDest;

          // 判断节点是否被标记
          private boolean flagged;

          // 选择测试的节点形状
          public static Polygon geometry = null;

          private final double ONE_RADIAN = Math.toRadians(1);

          // 给定ActorGroup2D object, 索引和位置创建Node 
          public Node(magic.actor2d.ActorGroup2D grp, int index, Vector2D p)
          {
               super(grp);

               animIndex = index;       
               circuitIndex = index;       
               circuitIndexDest = -1;

               setPos(p);
               dest = new Vector2D.Double();
               dest.setX(p.getX());
               dest.setY(p.getY());

               currAnimation = group.getAnimationStrip(animIndex);
               frameWidth    = currAnimation.getFrameWidth();
               frameHeight   = currAnimation.getFrameHeight();

               flagged = false;
          }

          // 判断节点的状态是否"正确"
          public boolean isCorrect()
          {
               // 如果节点的当前索引和目标索引一致则位置"正确"
               return (circuitIndex == circuitIndexDest);
          }

          // 判断一个Point是否为节点包含
          public boolean contains(Point p)
          {
              // 使用以原点为中心的几何形状，以节点的位置偏移这个Point来判断它是否在节点内
              return geometry.contains(new Point2D.Double(p.x - getX(), p.y - getY()));
          }

          // 交换两个节点的索引和目标位置
          public static void swap(Node a, Node b)
          {
               int temp = a.circuitIndex;
               a.circuitIndex = b.circuitIndex;
               b.circuitIndex = temp;

               a.dest.setX(b.pos.getX());
               a.dest.setY(b.pos.getY());

               b.dest.setX(a.pos.getX());
               b.dest.setY(a.pos.getY());
          }

          // 更新节点
          public void update()
          {
               if(isMoving())
               {
                    // 得到目标位置和当前位置之间的向量差 
                    Vector2D oneStep = dest.minus(pos);
                    
                    // 将步长正规化为单位长度
                    oneStep.normalize();

                    // 缩放步长，让节点移动得快一点
                    oneStep.scale(2.5);
                    
                    // 现在以步长值移动
                    pos.translate(oneStep);

                    // 根据移动方向旋转节点CW 或者 CCW
                    if(oneStep.getX() > 0.0)
                    {
                         rotation += ONE_RADIAN;
                    }
                    else
                    {
                         rotation -= ONE_RADIAN;
                    }
 
                    // 如果节点在单步允差范围内则"选取"节点
                    if(Math.abs(dest.getX()-pos.getX()) < oneStep.getX())
                    { 
                         pos.setX(dest.getX());
                    }

                    if(Math.abs(dest.getY()-pos.getY()) < oneStep.getY())
                    { 
                         pos.setY(dest.getY());
                    }

                    // 如果节点被放入目标位置则取消选取状态并将旋转度设为0
                    if(! isMoving()) 
                    {
                         setSelected(false);
                         rotation = 0;
                    }
               }

               // 让节点以它的参考点为中心并设置变换
               xform.setToIdentity();                            
               xform.translate(pos.getX(), pos.getY()); 
               xform.rotate(rotation); 
               xform.translate(-frameWidth/2, -frameHeight/2); 

               updateBounds();
               checkBounds();
          }

          public void paint(Graphics2D g2d)
          {
               super.paint(g2d);

               // 如果需要则绘制标记
               if(flagged && !isMoving())
               {
                    g2d.drawImage(NodeGroup.flag, AffineTransform.getTranslateInstance(
                                                      pos.getX()-NodeGroup.NODE_WIDTH/4,
                                                      pos.getY()-NodeGroup.NODE_HEIGHT),
                                  AnimationStrip.observer);

               }               
          }

          // 基本的访问方法 

          public void setAnimIndex(int index)
          {
               animIndex = index;       
               currAnimation = group.getAnimationStrip(animIndex);
          }

          public int getAnimIndex()
          {
               return animIndex;
          }

          public void setCircuitIndex(int index)
          {
               circuitIndex = index;
          }

          public int getCircuitIndex()
          {
               return circuitIndex;
          }

          public void setCircuitIndexDest(int index)
          {
               circuitIndexDest = index;
          }

          public int getCircuitIndexDest()
          {
               return circuitIndexDest;
          }

          // 为动画设置合适的帧
          public void setSelected(boolean s)
          {
              currAnimation.reset();
              if(s)
              {
                   animate(); 
              }
          }

          public boolean isMoving()
          {
               return(! pos.equals(dest));
          }

          public void toggleFlagged()
          {
               flagged = !flagged;
          }

          public boolean isFlagged()
          {
               return flagged;
          }

     }    // Node