puzzlemodel.java~24~

游戏名称：九宫阵 运行平台：j2me 规范：midp 说明：一款很经典的游戏源码

            naCurrentPuzzle[nCurrentLevel]++;
            if (naCurrentPuzzle[nCurrentLevel] >= nPuzzles)
                naCurrentPuzzle[nCurrentLevel] = 0;
     */
//      v0.8.0: should be shuffled!!!
//      spCurrentPuzzle = SuDoKuPuzzle.getPuzzle (saPuzzles [nCurrentLevel][naCurrentPuzzle[nCurrentLevel]]);
    spCurrentPuzzle = SuDoKuPuzzle.getPuzzle(shuffle(saPuzzles[nCurrentLevel][
        Math.abs(rand.nextInt()) % nPuzzles]));
    xCursor = 4;
    yCursor = 4;
    bWriting = false;
    writeAllNumbers();

    lStartTime = System.currentTimeMillis();
  }


//find next fitable value
//add by jack liu 2006-05-16
  private byte findNextValue(byte x, byte y){
    byte flag[] = {1,1,1,1,1,1,1,1,1};
    byte i,j;

    for(i=0;i<9;i++){
      byte v = spCurrentPuzzle.getValue(i, y);
      if(v !=0)
        flag[v] = 0;
      v = spCurrentPuzzle.getValue(x, i);
      if(v !=0)
        flag[v] = 0;
    }

    i = (byte)(x - (x%3));
    j = (byte)(y - (y%3));
    for(byte k1=0;k1<3;k1++){
      for(byte k2=0; k2<3; k2++){
        byte v = spCurrentPuzzle.getValue((byte)(i+k1), (byte)(j+k1));
        if (v != 0)
          flag[v] = 0;
      }
    }

    byte oldVal = spCurrentPuzzle.getValue(x, y);
    byte newVal = (byte)(oldVal + 1);
  }


  /** Handles input events
   * @param nKey the key code associated with the event
   */
  public void handleEvent(int nKey) {
    int nEvent = pvView.getGameAction(nKey);

    if ( (nInput == JOYPADNUMPAD) && (nKey <= pvView.KEY_NUM9) &&
        (nKey >= pvView.KEY_NUM0)) {
      if (!spCurrentPuzzle.isCarvedInStone(yCursor, xCursor)) {
        spCurrentPuzzle.setValueWithoutChecks(yCursor, xCursor,
                                              (byte) (nKey -
            PuzzleView.KEY_NUM0));
        pvView.writeNumber(xCursor, yCursor, (byte) (nKey - PuzzleView.KEY_NUM0),
                           (byte) (PuzzleView.CURSOR | PuzzleView.CORRECT));
        if (spCurrentPuzzle.isSolved())
          app.notifySolved(nCurrentLevel, naCurrentPuzzle[nCurrentLevel],
                           nPuzzles, System.currentTimeMillis() - lStartTime);
      }
      return;
    }

    if ( (nEvent != 0) && !bWriting) {
      if (nEvent == PuzzleView.LEFT) {
//                if (xCursor > 0)
//                {
        pvView.writeNumber(xCursor, yCursor,
                           spCurrentPuzzle.getValue(yCursor, xCursor),
                           (spCurrentPuzzle.isCarvedInStone(yCursor, xCursor) ?
                            PuzzleView.CARVEDINSTONE : PuzzleView.CORRECT));
//                    xCursor--;
        xCursor = (byte) ( (xCursor + 8) % 9);
        pvView.writeNumber(xCursor, yCursor,
                           spCurrentPuzzle.getValue(yCursor, xCursor),
                           (byte) (PuzzleView.CURSOR |
                                   (spCurrentPuzzle.
                                    isCarvedInStone(yCursor, xCursor) ?
                                    PuzzleView.CARVEDINSTONE :
                                    PuzzleView.CORRECT)));
//                }
      }
      else if (nEvent == PuzzleView.RIGHT) {
//                if (xCursor < 8)
//                {
        pvView.writeNumber(xCursor, yCursor,
                           spCurrentPuzzle.getValue(yCursor, xCursor),
                           (spCurrentPuzzle.isCarvedInStone(yCursor, xCursor) ?
                            PuzzleView.CARVEDINSTONE : PuzzleView.CORRECT));
//                    xCursor++;
        xCursor = (byte) ( (xCursor + 1) % 9);
        pvView.writeNumber(xCursor, yCursor,
                           spCurrentPuzzle.getValue(yCursor, xCursor),
                           (byte) (PuzzleView.CURSOR |
                                   (spCurrentPuzzle.
                                    isCarvedInStone(yCursor, xCursor) ?
                                    PuzzleView.CARVEDINSTONE :
                                    PuzzleView.CORRECT)));
//                }
      }
      else if (nEvent == PuzzleView.UP) {
//                if (yCursor > 0)
//                {
        pvView.writeNumber(xCursor, yCursor,
                           spCurrentPuzzle.getValue(yCursor, xCursor),
                           (spCurrentPuzzle.isCarvedInStone(yCursor, xCursor) ?
                            PuzzleView.CARVEDINSTONE : PuzzleView.CORRECT));
//                    yCursor--;
        yCursor = (byte) ( (yCursor + 8) % 9);
        pvView.writeNumber(xCursor, yCursor,
                           spCurrentPuzzle.getValue(yCursor, xCursor),
                           (byte) (PuzzleView.CURSOR |
                                   (spCurrentPuzzle.
                                    isCarvedInStone(yCursor, xCursor) ?
                                    PuzzleView.CARVEDINSTONE :
                                    PuzzleView.CORRECT)));
//                }
      }
      else if (nEvent == PuzzleView.DOWN) {
//                if (yCursor < 8)
//                {
        pvView.writeNumber(xCursor, yCursor,
                           spCurrentPuzzle.getValue(yCursor, xCursor),
                           (spCurrentPuzzle.isCarvedInStone(yCursor, xCursor) ?
                            PuzzleView.CARVEDINSTONE : PuzzleView.CORRECT));
//                    yCursor++;
        yCursor = (byte) ( (yCursor + 1) % 9);
        pvView.writeNumber(xCursor, yCursor,
                           spCurrentPuzzle.getValue(yCursor, xCursor),
                           (byte) (PuzzleView.CURSOR |
                                   (spCurrentPuzzle.
                                    isCarvedInStone(yCursor, xCursor) ?
                                    PuzzleView.CARVEDINSTONE :
                                    PuzzleView.CORRECT)));
//                }
      }
      else if (nEvent == PuzzleView.FIRE) {
        if (!spCurrentPuzzle.isCarvedInStone(yCursor, xCursor) &&
            (nInput != JOYPADNUMPAD)) {
          //{{modified by jack liu to enable playing with single numer key
          //old code
          /*
            bWriting = true;
            if (nInput == NONUMPAD)
                byTemp = spCurrentPuzzle.getValue (yCursor, xCursor);
           */
          //new code
          spCurrentPuzzle.setValueWithoutChecks(yCursor, xCursor,
                                                (byte) ((spCurrentPuzzle.getValue(yCursor, xCursor)+1)%10));
          pvView.writeNumber(xCursor, yCursor,
                             (byte) spCurrentPuzzle.getValue(yCursor, xCursor),
                             (byte) (PuzzleView.CURSOR | PuzzleView.CORRECT));
          if (spCurrentPuzzle.isSolved()) {
            app.notifySolved(nCurrentLevel, naCurrentPuzzle[nCurrentLevel],
                             nPuzzles, System.currentTimeMillis() - lStartTime);
          }
          //}}end of modify
        }
      }
    }
    else
    if (bWriting) {
      if ( (nKey >= PuzzleView.KEY_NUM0) && (nKey <= PuzzleView.KEY_NUM9) &&
          (nInput == NUMPAD)) {
        if (!spCurrentPuzzle.isCarvedInStone(yCursor, xCursor)) {
          spCurrentPuzzle.setValueWithoutChecks(yCursor, xCursor,
                                                (byte) (nKey -
              PuzzleView.KEY_NUM0));
          pvView.writeNumber(xCursor, yCursor,
                             (byte) (nKey - PuzzleView.KEY_NUM0),
                             (byte) (PuzzleView.CURSOR | PuzzleView.CORRECT));
          bWriting = false;
          if (spCurrentPuzzle.isSolved()) {
            app.notifySolved(nCurrentLevel, naCurrentPuzzle[nCurrentLevel],
                             nPuzzles, System.currentTimeMillis() - lStartTime);
          }
        }
      }
      else if ( (nEvent != 0) && (nInput == NONUMPAD)) {
        if ( (nEvent == PuzzleView.LEFT) || (nEvent == PuzzleView.DOWN))
          if (--byTemp < 0)
            byTemp = 9;
        if ( (nEvent == PuzzleView.RIGHT) || (nEvent == PuzzleView.UP))
          if (++byTemp > 9)
            byTemp = 0;
        if (nEvent == PuzzleView.FIRE) {
          bWriting = false;
          if (spCurrentPuzzle.isSolved()) {
            app.notifySolved(nCurrentLevel, naCurrentPuzzle[nCurrentLevel],
                             nPuzzles, System.currentTimeMillis() - lStartTime);
          }
        }
        else {
          spCurrentPuzzle.setValueWithoutChecks(yCursor, xCursor, byTemp);
          pvView.writeNumber(xCursor, yCursor, byTemp,
                             (byte) (PuzzleView.CURSOR | PuzzleView.CORRECT));
        }
      }
      else if ( (nInput == NUMPAD) && (nEvent == PuzzleView.FIRE))
        bWriting = false;
    }
  }

  /** Performs the necessary tasks before exiting
   */
  public void prepareForExit() {
    psStore.save(nCurrentLevel, naCurrentPuzzle,
                 spCurrentPuzzle.getPuzzleAsString(),
                 spCurrentPuzzle.getSolutionAsString(), pvView.getBackground(),
                 System.currentTimeMillis() - lStartTime, nInput);
  }

  /** Performs some shuffle operations on the given puzzle to generate a new one
   * @param s the puzzle to shuffle, encoded as a String
   * @return the shuffled puzzle, encoded as String
   */
  protected String shuffle(String s) {
    String sReturn = s;
    byte[] ba;
    byte b, t, i, j;

    for (b = 0; b < 3; b++) {
      ba = getShuffledArray( (byte) 3);
      sReturn = swapCols(s, ba, b);
      ba = getShuffledArray( (byte) 3);
      sReturn = swapRows(s, ba, b);
    }

    ba = getShuffledArray( (byte) 9);
    sReturn = swapNumbers(sReturn, ba);

    return sReturn;
  }

  /** Swaps columns in the given puzzle
   * @param s the puzzle, encoded as String
   * @param ba byte array representing the new column ordering
   * @param b byte representing the 3x3 block whose columns have to be swapped
   * @return the shuffled puzzle, encoded as String
   */
  protected String swapCols(String s, byte[] ba, byte b) {
    char[] caReturn = s.toCharArray();
    ;
    byte i, j;

    for (j = 0; j < ba.length; j++)
      if (j != ba[j])
        for (i = 0; i < 9; i++)
          caReturn[9 * i + 3 * b + j] = s.charAt(9 * i + 3 * b + ba[j]);

    return new String(caReturn);
  }

  /** Swaps rows in the given puzzle
   * @param s the puzzle, encoded as String
   * @param ba byte array representing the new row ordering
   * @param b byte representing the 3x3 block whose rows have to be swapped
   * @return the shuffled puzzle, encoded as String
   */
  protected String swapRows(String s, byte[] ba, byte b) {
    char[] caReturn = s.toCharArray();
    ;
    byte i, j;

    for (i = 0; i < ba.length; i++)
      if (i != ba[i])
        for (j = 0; j < 9; j++)
          caReturn[9 * (3 * b + i) + j] = s.charAt(9 * (3 * b + ba[i]) + j);

    return new String(caReturn);
  }

  /** Swaps numbers in the given puzzle
   * @param sOrig the puzzle, encoded as String
   * @param ba byte array representing a permutation of the {1, 2, ... 9} set
   * @return the shuffled puzzle, encoded as String
   */
  protected String swapNumbers(String sOrig, byte[] ba) {
    StringBuffer sbReturn = new StringBuffer(sOrig.length());
    byte yNum, yCiS;

    for (byte i = 0; i < sOrig.length(); i++) {
      yNum = (byte) (sOrig.charAt(i) - '0');
      yCiS = (byte) (yNum / 10);
      yNum = (byte) (yNum % 10);
      sbReturn.append( (char) ('0' + ba[yNum - 1] + 1 + 10 * yCiS));
    }

//        System.out.println ("sbReturn.toString()=" + sbReturn.toString());
    return sbReturn.toString();
  }

  /** Utility function that returns a random permutation of the {0, ... n - 1} byte-value set
   * @param n the dimension of the byte array
   * @return a byte array representing a permutation of the {0, ... n - 1} set
   */
  protected byte[] getShuffledArray(byte n) {
    byte[] baReturn = new byte[n];
    byte b, t, i, j;

    for (b = 0; b < n; b++)
      baReturn[b] = b;

    for (b = 0; b < 2 * n; b++) {
      i = (byte) (Math.abs(rand.nextInt()) % n);
      j = (byte) (Math.abs(rand.nextInt()) % n);
      t = baReturn[i];
      baReturn[i] = baReturn[j];
      baReturn[j] = t;
    }

    return baReturn;
  }
}