home *** CD-ROM | disk | FTP | other *** search
/ io Programmo 14 / IOPROG_14.ISO / soft / sdkjava / sdkjava.exe / SDKJava.cab / AFC102 / Samples / Puzzle15 / Src / Pz15GamePanel.java < prev    next >
Encoding:
Java Source  |  1998-03-05  |  9.6 KB  |  247 lines

  1. //
  2. // (c) 1997 Microsoft Corporation.  All rights reserved.
  3. //
  4. import java.awt.Image;
  5. import java.awt.Insets;
  6. import java.awt.Event;
  7. import com.ms.ui.*;
  8. import com.ms.fx.*;
  9.  
  10. class Pz15GamePanel extends UIGroup implements Pz15Consts
  11. {
  12.         private Pz15Data puzzle;
  13.         private Pz15Callbacks pzctrl;
  14.  
  15.         private Pz15AccGrfxBtn  btns[] = new Pz15AccGrfxBtn[NUM_BUTTONS];
  16.         private Pz15AccGrfxBtn  btnhole;
  17.         private FxTexture tex;
  18.  
  19.         public Pz15GamePanel(Pz15Data puzzle, Pz15Callbacks pzctrl)
  20.         {
  21.                 super();
  22.                 this.puzzle = puzzle; this.pzctrl = pzctrl;
  23.                 makeButtons();
  24.                 draw();
  25.                 setVisible(true);
  26.         }
  27.  
  28.         public void draw()
  29.         {
  30.                 setLayout(new UIGridLayout(PDIM, PDIM, 1, 1));
  31.  
  32.                 for (int i = 0 ; i < SIZE ; i++) {
  33.                         // Look for blank button
  34.                         if ( puzzle.current[i] == 0 )
  35.                                 add(btnhole);
  36.                         else
  37.                                 add(btns[puzzle.current[i]-1]);
  38.                 }
  39.                 btnhole.setBackground(null);
  40.                 btnhole.setStyle(0);
  41.                 btnhole.setEnabled(true); btnhole.setValid(true); btnhole.setEnabled(false);
  42.                 setValid(true);
  43.         }
  44.  
  45.         private void makeButtons()
  46.         {
  47.                 // Create "Hole" button and disable it
  48.                 btnhole = new Pz15AccGrfxBtn();
  49.                 btnhole.setEnabled(false);
  50.  
  51.                 // Create numbered buttons
  52.                 for (int i = 0 ; i < SIZE-1 ; i++) {
  53.                         btns[i] = new Pz15AccGrfxBtn(PIECES+i, pzctrl);
  54.                         btns[i].setBackground(BaseColor.getColor (new FxTexture(Pz15Images.get(BKGRND+i),
  55.                                                                                                 FxTexture.STRETCH_ALL,
  56.                                                                                                 0, 0, -1, -1, false, 185, 185, 185)));
  57.                 }
  58.         }
  59.  
  60.         public void setInitialFocus()
  61.         {
  62.                 int index;
  63.  
  64.                 if ( puzzle.hole > 11 )
  65.                         index = puzzle.hole + O_UP;
  66.                 else
  67.                         index = puzzle.hole + O_DOWN;
  68.  
  69.                 btns[puzzle.current[index]-1].requestFocus();
  70.         }
  71.  
  72.         public void update(int move)
  73.         {
  74.                 int index = move + puzzle.hole;
  75.  
  76.                 if ( move > 0 ) { // hole is moving DOWN or RIGHT
  77.                         move(index, puzzle.hole);
  78.                         move(puzzle.hole+1, index);
  79.                 }
  80.                 else { // hole must be moving UP or LEFT
  81.                         move(puzzle.hole, index);
  82.                         move(index+1, puzzle.hole);
  83.                 }
  84.  
  85.                 btns[puzzle.current[index]-1].requestFocus();
  86.                 // This setValid(false) is neccesary because of a bug in move()
  87.                 setValid(false);
  88.                 setValid(true);
  89.  
  90.                 // Now that we have updated the game board, we can update the internal
  91.                 //   representation of the puzzle.
  92.                 puzzle.update(move);
  93.  
  94.                 pzctrl.enableUndo(!puzzle.movstk.isEmpty());
  95.                 pzctrl.enableRestart(!puzzle.movstk.isEmpty());
  96.                 pzctrl.setNumMoves(puzzle.movstk.size());
  97.                 pzctrl.setMinMoves(puzzle.current_cost);
  98.                 if ( pzctrl.getSolverStatus() ) {
  99.                         if ( (puzzle.movstk.size() + puzzle.current_cost) > pzctrl.getOptimalCost() )
  100.                                 pzctrl.setMarqueeString(MRQ_NOHOPE, S_NOHOPE);
  101.                         else
  102.                                 pzctrl.setMarqueeString(MRQ_OPTIMALFND, S_OPTFND);
  103.                 }
  104.         }
  105.  
  106.         private MultMoves genMoves(int btn)
  107.         {
  108.                 // hole will move...
  109.                 int delta = puzzle.hole - btn;
  110.                 switch ( delta ) {
  111.                 case 4: case 8: case 12:
  112.                         return new MultMoves(O_UP, delta/4);
  113.  
  114.                 case -4: case -8: case -12:
  115.                         return new MultMoves(O_DOWN, -delta/4);
  116.  
  117.                 case 1: case 2: case 3:
  118.                         if ( btn/4 == puzzle.hole/4 )
  119.                                 return new MultMoves(O_LEFT, delta);
  120.                         break;
  121.  
  122.                 case -1: case -2: case -3:
  123.                         if ( btn/4 == puzzle.hole/4 )
  124.                                 return new MultMoves(O_RIGHT, -delta);
  125.                         break;
  126.                 }
  127.                 return new MultMoves(NO_MOVE, 0);
  128.         }
  129.  
  130.         public boolean action(Event e, Object arg)
  131.         {
  132.                 if ( puzzle.solved )
  133.                         return super.action(e, arg);
  134.  
  135.                 if ( arg instanceof UIPushButton ) {
  136.                         MultMoves moves = genMoves(getComponentIndex((UIPushButton)arg));
  137.  
  138.                         for ( int i = 0; i < moves.count; i++ ) {
  139.                                 update(moves.move);
  140.                                 if ( puzzle.solved ) {
  141.                                         congratulate();
  142.                                         break;
  143.                                 }
  144.                         }
  145.                 }
  146.                 return super.action(e, arg);
  147.         }
  148.  
  149.         public boolean keyDown(Event e, int key)
  150.         {
  151.                 int move = NO_MOVE;
  152.  
  153.                 if ( e.modifiers == 0 ) {
  154.                         switch ( key ) {
  155.                         case Event.UP: case Event.LEFT: case Event.RIGHT: case Event.DOWN:
  156.                                 if ( puzzle.solved )
  157.                                         return super.keyDown(e, key);
  158.                                 switch ( pzctrl.getNavMode() ) {
  159.                                 case M_BLANK: move = blankKeyDown(key); break;
  160.                                 case M_BUTTON: move = buttonKeyDown(key); break;
  161.                                 case M_SELECT: return super.keyDown(e, key);
  162.                                 default: break; // Can't get to here:
  163.                                                                 //   navmode is always one of three above
  164.                                 }
  165.                                 break;
  166.                         default: return super.keyDown(e, key);
  167.                         }
  168.                 }
  169.                 else
  170.                         return super.keyDown(e, key);
  171.  
  172.                 if ( move != NO_MOVE ) {
  173.                         update(move);
  174.                         if ( puzzle.solved )
  175.                                 congratulate();
  176.                 }
  177.                 return true; // keyDown was handled if we get to here
  178.         }
  179.  
  180.         private int blankKeyDown(int key)
  181.         {
  182.                 int move = NO_MOVE;
  183.  
  184.                 switch ( key ) {
  185.                 case Event.UP: move = puzzle.validateMove(O_UP); break;
  186.                 case Event.LEFT: move = puzzle.validateMove(O_LEFT); break;
  187.                 case Event.RIGHT: move = puzzle.validateMove(O_RIGHT); break;
  188.                 case Event.DOWN: move = puzzle.validateMove(O_DOWN); break;
  189.                 default: break; // Can't get to here since function is only called when
  190.                                                 //   key is already verified to be one of U,L,R,D
  191.                 }
  192.                 return move;
  193.         }
  194.  
  195.         private int buttonKeyDown(int key)
  196.         {
  197.                 int move = NO_MOVE;
  198.  
  199.                 switch ( key ) {
  200.                 case Event.UP: move = puzzle.validateMove(O_DOWN); break;
  201.                 case Event.LEFT: move = puzzle.validateMove(O_RIGHT); break;
  202.                 case Event.RIGHT: move = puzzle.validateMove(O_LEFT); break;
  203.                 case Event.DOWN: move = puzzle.validateMove(O_UP); break;
  204.                 default: break; // Can't get to here since function is only called when
  205.                                                 //   key is already verified to be one of U,L,R,D
  206.                 }
  207.                 return move;
  208.         }
  209.  
  210.         private void congratulate()
  211.         {
  212.                 drawBlank();
  213.                 pzctrl.enableUndo(false);
  214.                 if ( pzctrl.getSolverStatus() ) {
  215.                         if ( puzzle.movstk.size() == pzctrl.getOptimalCost() )
  216.                                 pzctrl.setMarqueeString(MRQ_CONGRATS, S_RESET);
  217.                         else
  218.                                 pzctrl.setMarqueeString(MRQ_OK, S_RESET);
  219.                 }
  220.                 else
  221.                         pzctrl.setMarqueeString(MRQ_OK_NOOPT, S_RESET);
  222.  
  223.                 pzctrl.congratulate();
  224.                 requestFocus();
  225.         }
  226.  
  227.         public void drawBlank()
  228.         {
  229.                 btnhole.setStyle(UIPushButton.RAISED | UIPushButton.THICK);
  230.                 btnhole.setBackground(BaseColor.getColor (new FxTexture(Pz15Images.get(BKGRND+SIZE-1),
  231.                                                                                                 FxTexture.STRETCH_ALL,
  232.                                                                                                 0, 0, -1, -1, false, 185, 185, 185)));
  233.                 // repaint background
  234.                 btnhole.setEnabled(true); btnhole.setValid(true); btnhole.setEnabled(false);
  235.         }
  236.  
  237.         public Insets getInsets() { return(new Insets(7,6,5,7)); }
  238. }
  239.  
  240. class MultMoves
  241. {
  242.         public int move;
  243.         public int count;
  244.  
  245.         public MultMoves(int mv, int cnt) {     move = mv; count = cnt; }
  246. }
  247.