/*
* Copyright © 2011 Nokia Corporation. All rights reserved.
* Nokia and Nokia Connecting People are registered trademarks of Nokia Corporation.
* Oracle and Java are trademarks or registered trademarks of Oracle and/or its
* affiliates. Other product and company names mentioned herein may be trademarks
* or trade names of their respective owners.
* See LICENSE.TXT for license information.
*/
package com.nokia.example.sudokumaster;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;
import javax.microedition.lcdui.game.TiledLayer;
public class SudokuView extends View {
private static final int BG0 = 1;
private static final int BG1 = 2;
private static final int BG0_HIGHLIGHTED = 3;
private static final int BG1_HIGHLIGHTED = 4;
private static final int BG_ERROR = 5;
private static final int ANIMATION_DURATION = 20;
private static final int NUMBER_COLOR = 0x000000ff;
private static final int PUZZLE_NUMBER_COLOR = 0x00000000;
private static final int BACKGROUND_COLOR = 0x004e2316;
private int[][] numbers = new int[9][9];
private int [][] puzzle = new int[9][9];
private int [][] animate = new int[9][9];
private TiledLayer board;
private Image boardImage;
private volatile boolean refreshBoard = true;
private Listener listener;
private int tileSize;
private int selectedCol = 4, selectedRow = 4;
private int moves = 0;
private long startTime;
private long victoryTimeSeconds = -1;
public SudokuView(Listener listener) {
super();
this.listener = listener;
}
public void setBoardImage(Image image) {
board = null;
boardImage = image;
refreshBoard = true;
}
public void setBoardSize(int boardSize) {
setSize(boardSize, boardSize);
tileSize = boardSize/9;
}
public void update() {
for(int col = 0; col < 9; col++) {
for(int row = 0; row < 9; row++) {
if(animate[col][row] > 0) {
boolean old = drawError(col, row);
animate[col][row]--;
if(old != drawError(col, row)) {
refreshBoard = true;
invalidate();
}
}
}
}
}
private boolean drawError(int col, int row) {
return 4*animate[col][row]/ANIMATION_DURATION % 2 == 1;
}
protected void paint(Graphics g) {
drawBoard(g);
drawNumbers(g);
}
private void drawBoard(Graphics g) {
g.setColor(BACKGROUND_COLOR);
g.fillRect(left, top, width, height);
if(boardImage == null) return;
if(board == null) {
board = new TiledLayer(9, 9, boardImage, boardImage.getWidth()/5, boardImage.getHeight());
board.setPosition(left, top);
}
if(refreshBoard) refreshBoard();
board.paint(g);
}
private void refreshBoard() {
refreshBoard = false;
board.fillCells(0, 0, 9, 9, BG0);
board.fillCells(0, 3, 3, 3, BG1);
board.fillCells(3, 0, 3, 3, BG1);
board.fillCells(3, 6, 3, 3, BG1);
board.fillCells(6, 3, 3, 3, BG1);
if(selectedCol >= 0 && selectedRow >= 0) {
for(int col = 0; col < 9; col++) {
if(col != selectedCol) {
final int bg = board.getCell(col, selectedRow) == BG0 ? BG0_HIGHLIGHTED : BG1_HIGHLIGHTED;
board.setCell(col, selectedRow, bg);
}
}
for(int row = 0; row < 9; row++) {
if(row != selectedRow) {
final int bg = board.getCell(selectedCol, row) == BG0 ? BG0_HIGHLIGHTED : BG1_HIGHLIGHTED;
board.setCell(selectedCol, row, bg);
}
}
}
for(int col = 0; col < 9; col++) {
for(int row = 0; row < 9; row++) {
if(animate[col][row] > 0 && drawError(col, row)) board.setCell(col, row, BG_ERROR);
}
}
}
private void drawNumbers(Graphics g) {
g.setColor(PUZZLE_NUMBER_COLOR);
final int xOffset = left + (tileSize + 1)/2;
final int yOffset = top + (tileSize + 1)/2 - g.getFont().getHeight()/2;
int x, y, n;
for(int col = 0; col < 9; col++) {
x = xOffset + col * tileSize;
for(int row = 0; row < 9; row++) {
y = yOffset + row * tileSize;
n = puzzle[col][row];
if(n > 0) {
g.drawString(String.valueOf(n), x, y, Graphics.HCENTER | Graphics.TOP);
}
}
}
g.setColor(NUMBER_COLOR);
for(int col = 0; col < 9; col++) {
x = xOffset + col * tileSize;
for(int row = 0; row < 9; row++) {
y = yOffset + row * tileSize;
n = numbers[col][row];
if(n > 0) {
g.drawString(String.valueOf(n), x, y, Graphics.HCENTER | Graphics.TOP);
}
}
}
}
public void handlePointerEvent(int type, int x, int y) {
if(!isVisible() || !hits(x, y)) return;
if(tileSize > 0) selectCell(Math.min((x - left) / tileSize, 8), Math.min((y - top) / tileSize, 8));
if(type == View.POINTER_RELEASED && puzzle[selectedCol][selectedRow] <= 0) listener.onCellSelected();
}
private void selectCell(int col, int row) {
selectedCol = col;
selectedRow = row;
refreshBoard = true;
invalidate();
}
public void keyEvent(final int type, final int key) {
if(type == KEY_RELEASED) return;
switch(key) {
case KEY_UP:
selectCell(selectedCol, (selectedRow - 1 + 9) % 9);
break;
case KEY_DOWN:
selectCell(selectedCol, (selectedRow + 1 + 9) % 9);
break;
case KEY_LEFT:
selectCell((selectedCol - 1 + 9) % 9, selectedRow);
break;
case KEY_RIGHT:
selectCell((selectedCol + 1 + 9) % 9, selectedRow);
break;
case KEY_SELECT:
if(type == KEY_PRESSED && puzzle[selectedCol][selectedRow] <= 0) listener.onCellSelected();
break;
}
}
public void setNumber(final int n) {
if(cellSelected() && puzzle[selectedCol][selectedRow] < 1) {
final int newNumber = n > 9 || n < 1? 0 : n;
if(validateNumber(n) && numbers[selectedCol][selectedRow] != newNumber) {
numbers[selectedCol][selectedRow] = newNumber;
moves++;
if(isComplete()) victoryTimeSeconds = getElapsedSeconds();
invalidate();
}
}
listener.onSetNumber();
}
private boolean cellSelected() {
return selectedCol >= 0 && selectedCol < 9 && selectedRow >= 0 && selectedCol < 9;
}
private int getNumber(final int col, final int row) {
if(puzzle[col][row] > 0) return puzzle[col][row];
return numbers[col][row];
}
private boolean validateNumber(final int n) {
return n == 0 || (validateRow(n) & validateCol(n) & validateBlock(n));
}
private boolean validateRow(final int n) {
for(int col = 0; col < 9; col++) {
if(getNumber(col, selectedRow) == n && col != selectedCol) {
animateCell(col, selectedRow);
return false;
}
}
return true;
}
private boolean validateCol(final int n) {
for(int row = 0; row < 9; row++) {
if(getNumber(selectedCol, row) == n && row != selectedRow) {
animateCell(selectedCol, row);
return false;
}
}
return true;
}
private boolean validateBlock(final int n) {
final int colOffset = selectedCol/3 * 3;
final int rowOffset = selectedRow/3 * 3;
int col, row;
for(int c = 0; c < 3; c++) {
col = colOffset + c;
for(int r = 0; r < 3; r++) {
row = rowOffset + r;
if(getNumber(col, row) == n && !(col == selectedCol && row == selectedRow)) {
animateCell(col, row);
return false;
}
}
}
return true;
}
private void animateCell(int col, int row) {
animate[col][row] = ANIMATION_DURATION;
refreshBoard = true;
invalidate();
}
public boolean isComplete() {
int n;
for(int i = 0; i < 9; i++) {
for(int j = 0; j < 9; j++) {
n = getNumber(i, j);
if(n <= 0) return false;
}
}
return true;
}
public static interface Listener {
void onCellSelected();
void onSetNumber();
}
public void restart() {
numbers = new int[9][9];
moves = 0;
startTime = System.currentTimeMillis();
victoryTimeSeconds = -1;
selectCell(4, 4);
}
public void newGame(int[][] puzzle) {
this.puzzle = puzzle;
restart();
}
public int getMoves() {
return moves;
}
public int getEmpty() {
int empty = 0;
int n;
for(int i = 0; i < 9; i++) {
for(int j = 0; j < 9; j++) {
n = getNumber(i, j);
if(n <= 0) empty++;
}
}
return empty;
}
public long getElapsedSeconds() {
if(victoryTimeSeconds > -1) return victoryTimeSeconds;
return (System.currentTimeMillis() - startTime) / 1000;
}
private void setElapsedSeconds(long elapsedSeconds) {
if(isComplete()) victoryTimeSeconds = elapsedSeconds;
startTime = System.currentTimeMillis() - elapsedSeconds * 1000;
}
public byte[] getState() {
ByteArrayOutputStream bout = null;
try {
bout = new ByteArrayOutputStream();
DataOutputStream dout = new DataOutputStream(bout);
for(int i = 0; i < 9; i++) {
for(int j = 0; j < 9; j++) {
dout.writeByte(puzzle[i][j]);
dout.writeByte(numbers[i][j]);
}
}
dout.writeByte(selectedCol);
dout.writeByte(selectedRow);
dout.writeInt(moves);
dout.writeLong(getElapsedSeconds());
return bout.toByteArray();
} catch (IOException e) {
return new byte[0];
} finally {
try {
if(bout != null) bout.close();
} catch (IOException e) {
}
}
}
public void setState(byte[] state) {
try {
DataInputStream din = new DataInputStream(new ByteArrayInputStream(state));
for(int i = 0; i < 9; i++) {
for(int j = 0; j < 9; j++) {
puzzle[i][j] = din.readByte();
numbers[i][j] = din.readByte();
}
}
selectedCol = din.readByte();
selectedRow = din.readByte();
moves = din.readInt();
setElapsedSeconds(din.readLong());
} catch (IOException e) {
}
}
}