@Override public synchronized boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; GameState other = (GameState) obj; if (backBuffer == null) { if (other.backBuffer != null) return false; } else if (!backBuffer.equals(other.backBuffer)) return false; if (epoch != other.epoch) return false; if (frontBuffer == null) { if (other.frontBuffer != null) return false; } else if (!frontBuffer.equals(other.frontBuffer)) return false; if (successfulExits != other.successfulExits) return false; if (unsuccessfulExits != other.unsuccessfulExits) return false; // Compare frontBuffer Map<Character, Plane> o = other.getFrontBuffer(); if (frontBuffer.size() != o.size()) return (false); Iterator<Character> it = frontBuffer.keySet().iterator(); Iterator<Character> it2 = o.keySet().iterator(); char c1, c2; while (it.hasNext()) { c1 = it.next(); c2 = it2.next(); if (c1 != c2 || !frontBuffer.get(c1).equals(o.get(c2))) return (false); } // Compare backBuffer o = other.getBackBuffer(); if (backBuffer.size() != o.size()) return (false); it = backBuffer.keySet().iterator(); it2 = o.keySet().iterator(); while (it.hasNext()) { c1 = it.next().charValue(); c2 = it2.next().charValue(); if (c1 != c2 || !backBuffer.get(c1).equals(o.get(c2))) return (false); } // Compare board Board b = other.getBoard(); if (b.getHeight() != board.getHeight() || b.getWidth() != board.getWidth() || b.getPorts().size() != board.getPorts().size()) return (false); it = board.getPorts().keySet().iterator(); it2 = b.getPorts().keySet().iterator(); while (it.hasNext()) { c1 = it.next().charValue(); c2 = it.next().charValue(); if (c1 != c2 || !b.getPorts().get(c1).equals(board.getPorts().get(c2))) return (false); } return true; }
public synchronized NewPlane createRandomPlane() { // Get an ID Random rand = new Random(); Character id = 'A'; int roll = rand.nextInt(26); for (int i = 0; i <= roll || frontBuffer.containsKey(id); i++, id++) ; // Get an exit gate Gate eg = board .getPorts() .values() .toArray(new Gate[26])[rand.nextInt(board.getPorts().size())] .clone(); // Get an entrance gate Gate ge; do ge = board .getPorts() .values() .toArray(new Gate[26])[rand.nextInt(board.getPorts().size())] .clone(); while (ge.getSymbol() == eg.getSymbol()); // Exit altitude int ea = rand.nextInt(9000); if (ea < 4000) ea = 3000; else ea = 7000; // Altitude int al = rand.nextInt(9000); if (al < 2667) al = 1000; else if (al < 5333) al = 5000; else al = 9000; // Set direction int di = 1; if (ge.getxCoord() == 0 && ge.getyCoord() == 0) di = 4; else if (ge.getxCoord() == 0 && ge.getyCoord() == board.getHeight() - 1) di = 2; else if (ge.getxCoord() == board.getWidth() - 1 && ge.getyCoord() == 0) di = 7; else if (ge.getxCoord() == board.getWidth() - 1 && ge.getyCoord() == board.getHeight() - 1) di = 9; else if (ge.getxCoord() == 0) di = 3; else if (ge.getxCoord() == board.getWidth() - 1) di = 8; else if (ge.getyCoord() == 0) di = 6; else if (ge.getyCoord() == board.getHeight() - 1) di = 1; // Return the new plane return (new NewPlane(ge.getSymbol(), eg.getSymbol(), di, ea, al)); }
public void setZoom(float i) { if (i < minZoom || i > 2.5F) return; int x_center, y_center; if (board.getLastMovew() != null) { x_center = board.getLastMovew().getColumn(); y_center = board.getLastMovew().getRow(); } else { x_center = (int) (position_x / (float) CELL_WIDTH + (getWidth() / (float) CELL_WIDTH) / 2); y_center = (int) (position_y / (float) CELL_HEIGHT + (getHeight() / (float) CELL_HEIGHT) / 2); } zoom = i; CELL_WIDTH = (int) (CELL_WIDTH_DEFAUTL * zoom); CELL_HEIGHT = (int) (CELL_HEIGHT_DEFAUTL * zoom); PIECE_WIDTH = (int) (PIECE_WIDTH_DEFAUTL * zoom); PIECE_HEIGHT = (int) (PIECE_HEIGHT_DEFAUTL * zoom); position_x = (int) ((x_center + 0.5F - (getWidth() / (float) CELL_WIDTH) / 2) * CELL_WIDTH); position_y = (int) ((y_center + 0.5F - (getHeight() / (float) CELL_HEIGHT) / 2) * CELL_HEIGHT); position_x = (position_x < 0) ? 0 : position_x; position_y = (position_y < 0) ? 0 : position_y; if (board.getWidth() * CELL_WIDTH <= getWidth() || board.getHeight() * CELL_HEIGHT <= getHeight()) { position_x = position_y = 0; } getbitbap(); update(); }
@Override protected void onSizeChanged(int w, int h, int oldw, int oldh) { minZoom = Math.min( (getWidth() / (float) board.getWidth()) / (float) CELL_WIDTH_DEFAUTL, (getHeight() / (float) board.getHeight()) / (float) CELL_HEIGHT_DEFAUTL); super.onSizeChanged(w, h, oldw, oldh); }
public BoardUI(Context c, final Board board) { super(c); this.board = board; ///////////////////////////////////////////// this.listeners = new ArrayList<MoveListener>(); minZoom = Math.min( (getWidth() / (float) board.getWidth()) / (float) CELL_WIDTH_DEFAUTL, (getHeight() / (float) board.getHeight()) / (float) CELL_HEIGHT_DEFAUTL); setZoom(1.5F); position_x = (board.getWidth() * CELL_WIDTH / 2 - getWidth()) / 2; position_y = (board.getHeight() * CELL_HEIGHT / 2 - getHeight()) / 2; getCol(); update(); }
/** * Die Anzahl der Sterne für die Zeile werden hier zurückgegeben * * @param iY - Hier wird die Positon des Feldes auf der Zeile angegeben * @param isMedium - Hier wird angegeben ob die Schwirigkeit mittel ist * @return stars - Die anzahl der ausgerechneten Sterne für die Zeile wird hier zurückgegeben */ public int getCalculatedRowStars(int iY, boolean isMedium) { int stars = _oBoard.getCountStarsForRow(iY); if (isMedium) { for (int iX = 0; iX < _oBoard.getWidth(); iX++) { if (_tmpDiff[iY][iX] == eStatesDiff.ISSTAR) { stars--; } } } return stars; }
/** * Gibt an ob das Board gelöst ist * * @return solved - Enthält den Status ob das Editor Board gelöst ist */ public boolean isSolved() { boolean solved = true; for (int iY = 0; iY < _oBoard.getHeight(); iY++) { for (int iX = 0; iX < _oBoard.getWidth(); iX++) { if (_tmpDiff[iY][iX] != eStatesDiff.BLOCKED && _tmpDiff[iY][iX] != eStatesDiff.ISSTAR) { return false; } } } return solved; }
/** * Displays the given game board. * * @param board The board to display. */ public void displayBoard(Board board) { int width = board.getWidth(); int height = board.getHeight(); int tileSize = determineTileSize(width, height); offsetTop = (boardView.getHeight() - (height * tileSize)) / 2; offsetLeft = (boardView.getWidth() - (width * tileSize)) / 2; // Start with an empty display. boardView.removeAllViews(); Ball ball; Goal goal; Man man; for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { switch (board.getBoardPiece(x, y)) { case Board.GOAL: goal = new Goal(this, tileSize, x, y); gameController.addGoal(goal); break; case Board.BALL: ball = new Ball(this, tileSize, x, y); gameController.addBall(ball); break; case Board.BALL_IN_GOAL: goal = new Goal(this, tileSize, x, y); gameController.addGoal(goal); ball = new Ball(this, tileSize, x, y); gameController.addBall(ball); break; case Board.MAN: man = new Man(this, tileSize, x, y); gameController.setMan(man); break; case Board.MAN_ON_GOAL: goal = new Goal(this, tileSize, x, y); gameController.addGoal(goal); man = new Man(this, tileSize, x, y); gameController.setMan(man); break; case Board.WALL: new Wall(this, tileSize, x, y); break; } if (board.isFloor(x, y)) { new Floor(this, tileSize, x, y); } } } }
/** Die Sterne die unlösbar sind werden hier in eine HashMap eingetragen */ public void calculatedUnsolvableStars() { HashMap<Integer, Integer> unsolvableStar = null; _unsolvableStars = new HashMap<Integer, HashMap<Integer, Integer>>(); for (int iY = 0; iY < _oBoard.getHeight(); iY++) { for (int iX = 0; iX < _oBoard.getWidth(); iX++) { unsolvableStar = new HashMap<Integer, Integer>(); Field oField = _oBoard.getField(iY, iX); if (oField.getState() == eStates.STAR && _tmpDiff[iY][iX] != eStatesDiff.ISSTAR) { unsolvableStar.put(iY, iX); _unsolvableStars.put(_unsolvableStars.size(), unsolvableStar); } } } }
/** * Constructs a new GUI minesweeper board. This constructor requires your own Board class that * you've been working on, and it will render the arrays in that class on the screen. * * @param board A board object to display. */ public MsGUI(Board board) { super("Minesweeper"); this.board = board; this.isEnabled = true; setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setSize(board.getWidth() * BUTTON_SIZE, board.getHeight() * BUTTON_SIZE); gamePanel = new JPanel(new GridLayout(board.getHeight(), board.getWidth())); buttons = new JButton[board.getHeight()][board.getWidth()]; for (int col = 0; col < board.getHeight(); col++) { for (int row = 0; row < board.getWidth(); row++) { JButton b = new JButton("" + board.getValue(row, col)); b.setBackground(new Color(200, 200, 200)); b.addMouseListener(new MineSquareListener(row, col)); buttons[row][col] = b; gamePanel.add(b); } } this.add(gamePanel); this.setVisible(true); }
/** Draws the game */ @Override protected void paintComponent(Graphics g) { super.paintComponent(g); final Graphics2D g2 = (Graphics2D) g; /** Draw all the non-falling blocks on the board. Non-OUTSIDE blocks have rounded corners. */ for (int row = 0; row < board.getHeight(); row++) { for (int column = 0; column < board.getWidth(); column++) { if (board.getSquareType(row, column) != SquareType.OUTSIDE) { Shape tetrominoBlock = new RoundRectangle2D.Double( column * SQUARE_WIDTH, row * SQUARE_HEIGHT, SQUARE_WIDTH, SQUARE_HEIGHT, 5, 5); g2.setColor(SQUARE_COLOR.get(board.getSquareType(row, column))); g2.fill(tetrominoBlock); g2.draw(tetrominoBlock); } else { Shape tetrominoBlock = new Rectangle2D.Double( column * SQUARE_WIDTH, row * SQUARE_HEIGHT, SQUARE_WIDTH, SQUARE_HEIGHT); g2.setColor(SQUARE_COLOR.get(board.getSquareType(row, column))); g2.fill(tetrominoBlock); g2.draw(tetrominoBlock); } } } Poly tempPoly = board.getFalling(); if (tempPoly != null) { for (int row = 0; row < tempPoly.getSize(); row++) { for (int column = 0; column < tempPoly.getSize(); column++) { if (tempPoly.getSquareType(row, column) != SquareType.EMPTY) { Shape tetrominoBlock = new RoundRectangle2D.Double( (column + board.getFallingPosX()) * SQUARE_WIDTH, (row + board.getFallingPosY()) * SQUARE_HEIGHT, SQUARE_WIDTH, SQUARE_HEIGHT, 5, 5); g2.setColor(SQUARE_COLOR.get(tempPoly.getSquareType(row, column))); g2.fill(tetrominoBlock); g2.draw(tetrominoBlock); } } } } }
/** * Take a single step of the simulation. This is done by walking through each cell and calculating * its new state by applying the rules in their order until either one applies and yields a new * state, or not apply (hence, the original state is retained). */ public void step() { int width = board.getWidth(); int height = board.getHeight(); // nCells holds the updated state for each cell on the board. int[] nCells = new int[width * height]; /* * Now visit each cell and compute it's updated cell. Note that we don't update the board * yet. This is to prevent one cell from seeing the updated state of another cell in the * same step. */ for (int x = 0; x < width; ++x) { for (int y = 0; y < height; ++y) { nCells[(y * width) + x] = board.getCellState(x, y); Point p = new Point(x, y); for (Rule r : rules) { // Apply the rule Integer result = r.apply(new Pair<Point, Board>(p, board)); if (result != null && result >= 0 && result <= 9) { /* * Yes, the rule was successfully applied. Therefore, update the cell's * state and move onto the next cell. */ nCells[(y * width) + x] = result; break; } } } } // Finally, go through and update each cell on the board with its new state. for (int x = 0; x < width; ++x) { for (int y = 0; y < height; ++y) { int nState = nCells[(y * width) + x]; board.setCellState(x, y, nState); } } }
@Override public boolean onTouchEvent(MotionEvent event) { if (event.getAction() == MotionEvent.ACTION_DOWN) { LastTouch.x = (int) event.getX(); LastTouch.y = (int) event.getY(); float x = LastTouch.x + position_x - LEFT_MARGIN; float y = LastTouch.y + position_y - TOP_MARGIN; celltouch.x = (int) (x / CELL_WIDTH); celltouch.y = (int) (y / CELL_WIDTH); mButtonPressed = true; update(); } if (event.getAction() == MotionEvent.ACTION_MOVE) { final float x = event.getX() + position_x - LEFT_MARGIN; final float y = event.getY() + position_y - TOP_MARGIN; if ((int) (x / CELL_WIDTH) == (int) ((LastTouch.x + position_x - LEFT_MARGIN) / CELL_WIDTH) && (int) (y / CELL_HEIGHT) == (int) ((LastTouch.y + position_y - TOP_MARGIN) / CELL_HEIGHT) && mButtonPressed == true) { return true; } mButtonPressed = false; // Calculate the distance moved final float dx = event.getX() - LastTouch.x; final float dy = event.getY() - LastTouch.y; // Move position_x -= dx; position_y -= dy; // Remember this touch position for the next move event LastTouch.x = (int) event.getX(); LastTouch.y = (int) event.getY(); position_x = (position_x < 0) ? 0 : position_x; position_y = (position_y < 0) ? 0 : position_y; position_x = (position_x + getWidth() > board.getWidth() * CELL_WIDTH - LEFT_MARGIN) ? (board.getWidth() * CELL_WIDTH + LEFT_MARGIN * 2 - getWidth()) : position_x; position_y = (position_y + getHeight() > board.getHeight() * CELL_HEIGHT - TOP_MARGIN) ? (board.getHeight() * CELL_HEIGHT + TOP_MARGIN * 2 - getHeight()) : position_y; position_x = (getWidth() > board.getWidth() * CELL_WIDTH - LEFT_MARGIN) ? 0 : position_x; position_y = (getHeight() > board.getHeight() * CELL_HEIGHT - TOP_MARGIN) ? 0 : position_y; update(); return true; } if (event.getAction() == MotionEvent.ACTION_UP) { if (mButtonPressed == false) return true; mButtonPressed = false; update(); if (celltouch.x >= board.getWidth() || celltouch.y >= board.getHeight()) return true; fireMoveMade(new Move(celltouch.y, celltouch.x, board.getCurrentPiece())); return super.onTouchEvent(event); } return super.onTouchEvent(event); }
public boolean isArrowPointingAtField(int yPos, int xPos) { int adder = 0; // is there a north arrow pointing at me? for (int iY = yPos + 1; iY < _oBoard.getHeight(); iY++) { if (_oBoard.getField(iY, xPos).getState() == eStates.ARROW_N) { return true; } } // is there a south arrow pointing at me? for (int iY = 0; iY < yPos; iY++) { if (_oBoard.getField(iY, xPos).getState() == eStates.ARROW_S) { return true; } } // is there a west arrow pointing at me? for (int iX = xPos + 1; iX < _oBoard.getWidth(); iX++) { if (_oBoard.getField(yPos, iX).getState() == eStates.ARROW_W) { return true; } } // is there a east arrow pointing at me? for (int iX = 0; iX < xPos; iX++) { if (_oBoard.getField(yPos, iX).getState() == eStates.ARROW_E) { return true; } } // is there a northeast arrow pointing at me? adder = 1; while (((yPos - adder) >= 0) && ((xPos + adder) < _oBoard.getWidth())) { if (_oBoard.getField((yPos - adder), (xPos + adder)).getState() == eStates.ARROW_SW) { return true; } adder++; } // is there a southeast arrow pointing at me? adder = 1; while (((yPos + adder) < _oBoard.getHeight()) && ((xPos + adder) < _oBoard.getWidth())) { if (_oBoard.getField((yPos + adder), (xPos + adder)).getState() == eStates.ARROW_NW) { return true; } adder++; } // is there a northwest arrow pointing at me? adder = 1; while (((yPos - adder) >= 0) && ((xPos - adder) >= 0)) { if (_oBoard.getField((yPos - adder), (xPos - adder)).getState() == eStates.ARROW_SE) { return true; } adder++; } // is there a southwest arrow pointing at me? adder = 1; while (((yPos + adder) < _oBoard.getHeight()) && ((xPos - adder) >= 0)) { if (_oBoard.getField((yPos + adder), (xPos - adder)).getState() == eStates.ARROW_NE) { return true; } adder++; } return false; }
/** * Handles the events for keypresses * * @param e the pressed key */ public void keyPressed(KeyEvent e) { if (activePentomino != null) { // Keys for moveing the pentomino sideways if (e.getKeyCode() == KeyEvent.VK_LEFT || e.getKeyCode() == KeyEvent.VK_RIGHT) { // Initialize direction to 0 to make sure we don't get null pointer exception // or do something weird with the movement int direction = 0; if (e.getKeyCode() == KeyEvent.VK_LEFT) direction = -1; if (e.getKeyCode() == KeyEvent.VK_RIGHT) direction = 1; // +1 right, -1 left // Check if we are allowed to actually move the pentomino to the new position boolean legalMove = true; for (Point p : activePentomino.getLocation()) { int newX = (int) (p.getX() + pentominoLocation.getX() + direction); int newY = (int) (p.getY() + pentominoLocation.getY()); // Check only if the pentomino is not above the board if (newY >= 0) { // Check that we are horizontally within the board and not trying to overlap another // piece if (newX < 0 || newX >= gameBoard.getBoard().length || gameBoard.getBoard()[newX][newY] != -1) legalMove = false; } } // Check passed so we do the actual movement of the pentomino if (legalMove) { pentominoLocation.setLocation( (pentominoLocation.getX() + direction), pentominoLocation.getY()); predictDrop(); updateMatrix(); } } // Key for rotating the pentomino if (e.getKeyCode() == KeyEvent.VK_UP) { // Create a temporary pentomino to check if the rotated position free Pentomino tmpPentomino = activePentomino.copy(); tmpPentomino.rotate(); boolean legalMove = true; // For reach block of the position check that it's free and within the grid // ignoring the check if we're above the grid for (Point p : tmpPentomino.getLocation()) { int newX = (int) (p.getX() + pentominoLocation.getX()); int newY = (int) (p.getY() + pentominoLocation.getY()); if (newY > 0) { if (newY >= gameBoard.getBoard()[0].length || newX < 0 || newX >= gameBoard.getBoard().length || gameBoard.getBoard()[newX][newY] != -1) { legalMove = false; } } } // If the check passed then simply do the rotation if (legalMove) { activePentomino.rotate(); predictDrop(); } // Update the matrix so we don't have lag in display updateMatrix(); } // Key for speeding up the fall if (e.getKeyCode() == KeyEvent.VK_DOWN) { // If next position is available, put the current pentomino to it if (nextDropLegal(activePentomino, gameBoard.getBoard(), pentominoLocation)) { pentominoLocation.setLocation(pentominoLocation.getX(), pentominoLocation.getY() + 1); } // Update to avoid lag updateMatrix(); } // Key for entirely dropping the pentomino if (e.getKeyCode() == KeyEvent.VK_ENTER) { // We make the pentomino fall as many times as it can while (nextDropLegal(activePentomino, gameBoard.getBoard(), pentominoLocation)) { pentominoLocation.setLocation(pentominoLocation.getX(), pentominoLocation.getY() + 1); } // Update to avoid lag updateMatrix(); } // Key for flipping the pentomino if (e.getKeyCode() == KeyEvent.VK_SPACE) { // Create a temporary pentomino for checking the flipped position Pentomino tmpPentomino = activePentomino.copy(); tmpPentomino.reflect(); // Check that each position in the temporary pentomino is available and within the matrix boolean legalMove = true; for (Point p : tmpPentomino.getLocation()) { int newX = (int) (p.getX() + pentominoLocation.getX()); int newY = (int) (p.getY() + pentominoLocation.getY()); if (newY < 0 || newY >= gameBoard.getBoard()[0].length || newX < 0 || newX >= gameBoard.getBoard().length || gameBoard.getBoard()[newX][newY] != -1) { legalMove = false; } } // Flip the pentomino if check is passed if (legalMove) { activePentomino.reflect(); predictDrop(); } // Update to avoid lag updateMatrix(); } // Key for storing the currently falling pentomino if (e.getKeyCode() == KeyEvent.VK_SHIFT) { // If we haven't stored after fixing the pentomino to the grid if (storageable) { // Change the active and stored pentomino and set the location to the top of the screen pentominoLocation = new Point(gameBoard.getWidth() / 2, 0); Pentomino tmp = activePentomino; activePentomino = storagedPentomino; storagedPentomino = tmp; storageable = false; // Get new prediction predictDrop(); // Update to avoid lag updateMatrix(); } } // Key for a chect for testing purposes if (e.getKeyCode() == KeyEvent.VK_X) { // If pressed enough, add score cheat++; if (cheat > 10) { cheat = 0; addScore(12); } } } }
private boolean blockSpecialAlgorigthm() { boolean hasChanged = false; boolean containsUpwardArrow = false; boolean containsDownwardArrow = false; for (int iX = 0; iX < _oBoard.getWidth(); iX++) { System.out.println("1"); int columnStars = getCalculatedColumnStars(iX, true); if (1 == columnStars) { containsUpwardArrow = false; containsDownwardArrow = false; for (int iY = 0; iY < _oBoard.getHeight(); iY++) { System.out.println("2"); Field oField = _oBoard.getField(iY, iX); if (oField.getState() == eStates.ARROW_N) { containsDownwardArrow = true; } if (oField.getState() == eStates.ARROW_S) { containsUpwardArrow = true; } } if (containsUpwardArrow) { // collect Fields that are Pointed by Arrow for (int iY = _oBoard.getHeight() - 1; iY >= 0; iY--) { System.out.println("3"); Field oField = _oBoard.getField(iY, iX); if (oField.getState() == eStates.ARROW_S) { for (int iY2 = iY; iY2 >= 0; iY2--) { System.out.println("4"); boolean tmpChanged = updateTmpFields(iY2, iX, eStatesDiff.BLOCKED); if (!hasChanged) { hasChanged = tmpChanged; } } break; } } } if (containsDownwardArrow) { // collect Fields that are Pointed by Arrow for (int iY = 0; iY < _oBoard.getHeight(); iY++) { System.out.println("5"); Field oField = _oBoard.getField(iY, iX); if (oField.getState() == eStates.ARROW_N) { for (int iY2 = iY; iY2 < _oBoard.getHeight(); iY2++) { System.out.println("6"); boolean tmpChanged = updateTmpFields(iY2, iX, eStatesDiff.BLOCKED); if (!hasChanged) { hasChanged = tmpChanged; } } break; } } } } } for (int iY = 0; iY < _oBoard.getHeight(); iY++) { int rowStars = getCalculatedColumnStars(iY, true); if (1 == rowStars) { containsUpwardArrow = false; containsDownwardArrow = false; for (int iX = 0; iX < _oBoard.getWidth(); iX++) { Field oField = _oBoard.getField(iY, iX); if (oField.getState() == eStates.ARROW_W) { containsDownwardArrow = true; } if (oField.getState() == eStates.ARROW_E) { containsUpwardArrow = true; } } if (containsUpwardArrow) { // collect Fields that are Pointed by Arrow for (int iX = _oBoard.getWidth() - 1; iX >= 0; iX--) { Field oField = _oBoard.getField(iY, iX); if (oField.getState() == eStates.ARROW_E) { for (int iX2 = iX; iX2 >= 0; iX2--) { boolean tmpChanged = updateTmpFields(iY, iX2, eStatesDiff.BLOCKED); if (!hasChanged) { hasChanged = tmpChanged; } } break; } } } if (containsDownwardArrow) { // collect Fields that are Pointed by Arrow for (int iX = 0; iX < _oBoard.getWidth(); iX++) { Field oField = _oBoard.getField(iY, iX); if (oField.getState() == eStates.ARROW_W) { for (int iX2 = iX; iX2 < _oBoard.getHeight(); iX2++) { boolean tmpChanged = updateTmpFields(iY, iX2, eStatesDiff.BLOCKED); if (!hasChanged) { hasChanged = tmpChanged; } } break; } } } } } return hasChanged; }
/** * Konstruktor der Klasse CheckEditorBoardDifficulty Das Editor Board wird nach der Schwirigkeit * geprüft * * @return BOARD_DIFFICULTY_EASY = "einfach" - Hier wird angegeben, dass das Board die * Schwirigkeit leicht hat * @return BOARD_DIFFICULTY_MEDIUM = Hier wird angegeben, dass das Board die Schwirigkeit mittel * hat * @return BOARD_DIFFICULTY_HARD = Hier wird angegeben, dass das Board die Schwirigkeit schwer hat * @return BOARD_DIFFICULTY_NOT_SOLVABLE = Hier wird angegeben, dass das Board die Schwirigkeit * unlösbar hat */ public String checkDifficulty() { /** Dekleration der Variabeln für die Funktion checkDifficulty */ _tmpDiff = new eStatesDiff[_oBoard.getHeight()][_oBoard.getWidth()]; boolean isSolvable = false; boolean doMediumSearch = false; boolean doHardSearch = false; boolean isSolved = false; boolean hasChanged = true; int tmpStarCount = 0; int tmpEmptyFields = 0; int counter = 0; boolean foundEmptySpot = false; int foundSpotX = -1; int foundSpotY = -1; int adder = 0; // go through logicuntil game is solved or stop when no changes were made in last run while (!isSolved && hasChanged) { hasChanged = false; for (int iY = 0; iY < _oBoard.getHeight(); iY++) { int rowStars = getCalculatedRowStars(iY, doMediumSearch); for (int iX = 0; iX < _oBoard.getWidth(); iX++) { int columnStars = getCalculatedColumnStars(iX, doMediumSearch); Field oField = _oBoard.getField(iY, iX); if (0 == columnStars || 0 == rowStars || isArrow(oField.getState())) { boolean tmpChanged = updateTmpFields(iY, iX, eStatesDiff.BLOCKED); if (!hasChanged) { hasChanged = tmpChanged; } } if (!isArrowPointingAtField(iY, iX)) { boolean tmpChanged = updateTmpFields(iY, iX, eStatesDiff.BLOCKED); if (!hasChanged) { hasChanged = tmpChanged; } } } tmpEmptyFields = 0; for (int iX2 = 0; iX2 < _oBoard.getWidth(); iX2++) { if (_tmpDiff[iY][iX2] != eStatesDiff.BLOCKED && _tmpDiff[iY][iX2] != eStatesDiff.ISSTAR) { tmpEmptyFields++; } } if (tmpEmptyFields == rowStars) { for (int iX2 = 0; iX2 < _oBoard.getWidth(); iX2++) { if (_tmpDiff[iY][iX2] != eStatesDiff.BLOCKED) { boolean tmpChanged = updateTmpFields(iY, iX2, eStatesDiff.ISSTAR); if (!hasChanged) { hasChanged = tmpChanged; } } } } } tmpEmptyFields = 0; for (int iX = 0; iX < _oBoard.getWidth(); iX++) { tmpEmptyFields = 0; int columnStars = getCalculatedColumnStars(iX, doMediumSearch); for (int iY = 0; iY < _oBoard.getHeight(); iY++) { if (_tmpDiff[iY][iX] != eStatesDiff.BLOCKED && _tmpDiff[iY][iX] != eStatesDiff.ISSTAR) { tmpEmptyFields++; } } if (tmpEmptyFields == columnStars) { for (int iY2 = 0; iY2 < _oBoard.getWidth(); iY2++) { if (_tmpDiff[iY2][iX] != eStatesDiff.BLOCKED) { boolean tmpChanged = updateTmpFields(iY2, iX, eStatesDiff.ISSTAR); if (!hasChanged) { hasChanged = tmpChanged; } } } } } // cross calculation for (int iX = 0; iX < _oBoard.getWidth(); iX++) { tmpEmptyFields = 0; for (int iY = 0; iY < _oBoard.getHeight(); iY++) { foundEmptySpot = false; foundSpotX = -1; foundSpotY = -1; Field oField = _oBoard.getField(iY, iX); if (oField.getState() == eStates.ARROW_SW) { adder = 1; while (((iY + adder) < _oBoard.getHeight()) && ((iX - adder) >= 0)) { if (_tmpDiff[iY + adder][iX - adder] != eStatesDiff.BLOCKED && _tmpDiff[iY + adder][iX - adder] != eStatesDiff.ISSTAR) { if (!foundEmptySpot) { foundSpotX = iX - adder; foundSpotY = iY + adder; foundEmptySpot = true; } else { foundSpotX = -1; foundSpotY = -1; foundEmptySpot = false; break; } } adder++; } } else if (oField.getState() == eStates.ARROW_SE) { adder = 1; while (((iY + adder) < _oBoard.getHeight()) && ((iX + adder) < _oBoard.getWidth())) { if (_tmpDiff[iY + adder][iX + adder] != eStatesDiff.BLOCKED && _tmpDiff[iY + adder][iX + adder] != eStatesDiff.ISSTAR) { if (!foundEmptySpot) { foundSpotX = iX + adder; foundSpotY = iY + adder; foundEmptySpot = true; } else { foundSpotX = -1; foundSpotY = -1; foundEmptySpot = false; break; } } adder++; } } else if (oField.getState() == eStates.ARROW_NW) { adder = 1; while (((iY - adder) >= 0) && ((iX - adder) >= 0)) { if (_tmpDiff[iY - adder][iX - adder] != eStatesDiff.BLOCKED && _tmpDiff[iY - adder][iX - adder] != eStatesDiff.ISSTAR) { if (!foundEmptySpot) { foundSpotX = iX - adder; foundSpotY = iY - adder; foundEmptySpot = true; } else { foundSpotX = -1; foundSpotY = -1; foundEmptySpot = false; break; } } adder++; } } else if (oField.getState() == eStates.ARROW_NE) { adder = 1; while (((iY - adder) >= 0) && ((iX + adder) < _oBoard.getWidth())) { if (_tmpDiff[iY - adder][iX + adder] != eStatesDiff.BLOCKED && _tmpDiff[iY - adder][iX + adder] != eStatesDiff.ISSTAR) { if (!foundEmptySpot) { foundSpotX = iX + adder; foundSpotY = iY - adder; foundEmptySpot = true; } else { foundSpotX = -1; foundSpotY = -1; foundEmptySpot = false; break; } } adder++; } } if (foundEmptySpot) { boolean tmpChanged = updateTmpFields(foundSpotY, foundSpotX, eStatesDiff.ISSTAR); if (!hasChanged) { hasChanged = tmpChanged; } foundSpotX = -1; foundSpotY = -1; } } } if (doHardSearch) { boolean upCheckDone = false; boolean downCheckDone = false; foundEmptySpot = false; foundSpotX = -1; foundSpotY = -1; for (int iX = 0; iX < _oBoard.getWidth(); iX++) { upCheckDone = false; downCheckDone = false; int columnStars = getCalculatedColumnStars(iX, doHardSearch); if (1 <= columnStars) { // up check for (int iY = 0; iY < _oBoard.getHeight(); iY++) { foundEmptySpot = false; Field oField = _oBoard.getField(iY, iX); if (!upCheckDone && oField.getState() == eStates.ARROW_N) { upCheckDone = true; for (int iTmpY = 0; iTmpY < iY; iTmpY++) { if (_tmpDiff[iTmpY][iX] != eStatesDiff.BLOCKED && _tmpDiff[iTmpY][iX] != eStatesDiff.ISSTAR) { if (!foundEmptySpot) { foundSpotX = iX; foundSpotY = iTmpY; foundEmptySpot = true; } else { foundSpotX = -1; foundSpotY = -1; foundEmptySpot = false; break; } } } if (foundEmptySpot) { boolean tmpChanged = updateTmpFields(foundSpotY, foundSpotX, eStatesDiff.ISSTAR); if (!hasChanged) { hasChanged = tmpChanged; } foundSpotX = -1; foundSpotY = -1; } } } // down check for (int iY = _oBoard.getHeight() - 1; iY >= 0; iY--) { foundEmptySpot = false; Field oField = _oBoard.getField(iY, iX); if (!downCheckDone && oField.getState() == eStates.ARROW_S) { downCheckDone = true; for (int iTmpY = iY + 1; iTmpY < _oBoard.getHeight(); iTmpY++) { if (_tmpDiff[iTmpY][iX] != eStatesDiff.BLOCKED && _tmpDiff[iTmpY][iX] != eStatesDiff.ISSTAR) { if (!foundEmptySpot) { foundSpotX = iX; foundSpotY = iTmpY; foundEmptySpot = true; } else { foundSpotX = -1; foundSpotY = -1; foundEmptySpot = false; break; } } } if (foundEmptySpot) { boolean tmpChanged = updateTmpFields(foundSpotY, foundSpotX, eStatesDiff.ISSTAR); if (!hasChanged) { hasChanged = tmpChanged; } foundSpotX = -1; foundSpotY = -1; } } } } } for (int iY = 0; iY < _oBoard.getHeight(); iY++) { upCheckDone = false; downCheckDone = false; int rowStars = getCalculatedRowStars(iY, doHardSearch); if (1 <= rowStars) { // up check for (int iX = 0; iX < _oBoard.getWidth(); iX++) { foundEmptySpot = false; Field oField = _oBoard.getField(iY, iX); if (!upCheckDone && oField.getState() == eStates.ARROW_W) { upCheckDone = true; for (int iTmpX = 0; iTmpX < iX; iTmpX++) { if (_tmpDiff[iY][iTmpX] != eStatesDiff.BLOCKED && _tmpDiff[iY][iTmpX] != eStatesDiff.ISSTAR) { if (!foundEmptySpot) { foundSpotX = iTmpX; foundSpotY = iY; foundEmptySpot = true; } else { foundSpotX = -1; foundSpotY = -1; foundEmptySpot = false; break; } } } if (foundEmptySpot) { boolean tmpChanged = updateTmpFields(foundSpotY, foundSpotX, eStatesDiff.ISSTAR); if (!hasChanged) { hasChanged = tmpChanged; } foundSpotX = -1; foundSpotY = -1; } } } // up check for (int iX = _oBoard.getWidth() - 1; iX >= 0; iX--) { foundEmptySpot = false; Field oField = _oBoard.getField(iY, iX); if (!downCheckDone && oField.getState() == eStates.ARROW_E) { downCheckDone = true; for (int iTmpX = iX + 1; iTmpX < _oBoard.getWidth(); iTmpX++) { if (_tmpDiff[iY][iTmpX] != eStatesDiff.BLOCKED && _tmpDiff[iY][iTmpX] != eStatesDiff.ISSTAR) { if (!foundEmptySpot) { foundSpotX = iTmpX; foundSpotY = iY; foundEmptySpot = true; } else { foundSpotX = -1; foundSpotY = -1; foundEmptySpot = false; break; } } } if (foundEmptySpot) { boolean tmpChanged = updateTmpFields(foundSpotY, foundSpotX, eStatesDiff.ISSTAR); if (!hasChanged) { hasChanged = tmpChanged; } foundSpotX = -1; foundSpotY = -1; } } } } } if (!hasChanged) { boolean tmpChanged = blockSpecialAlgorigthm(); if (!hasChanged) { hasChanged = tmpChanged; } } } isSolved = isSolved(); counter++; if (!isSolved && !doMediumSearch && (counter > 1 || !hasChanged)) { // its medium doMediumSearch = true; hasChanged = true; } if (!isSolved && doMediumSearch && !doHardSearch && (counter > 5 || !hasChanged)) { // its medium doHardSearch = true; hasChanged = true; } } if (isSolved && !doMediumSearch && counter < 2) { return BOARD_DIFFICULTY_EASY; } else if (isSolved && counter < 6) { return BOARD_DIFFICULTY_MEDIUM; } else if (isSolved) { return BOARD_DIFFICULTY_HARD; } else { calculatedUnsolvableStars(); return BOARD_DIFFICULTY_NOT_SOLVABLE; } }
public void center() { position_x = (board.getWidth() * CELL_WIDTH - getWidth()) / 2; position_y = (board.getHeight() * CELL_HEIGHT - getHeight()) / 2; }
private synchronized void processTick(Tick tick) { int x, y; // Fazer as opera��es primeiro por causa dos observers no swapBuffers() // Por os avi�es a marchar for (Plane p : backBuffer.values()) p.move(); // Remover os avi�es que saem do mapa boolean succ = false; Set<Character> remover = new TreeSet<Character>(); for (Plane p : backBuffer .values()) { // A diferen�a entre tirar logo quando ele chega na porta ou tirar depois // de ter passado um epoch na porta x = p.getxCoord(); y = p.getyCoord(); if (x <= 0 || y <= 0 || y >= board.getHeight() || x >= board.getWidth()) { for (Gate g : board.getPorts().values()) if (g.getxCoord() == x && g.getyCoord() == y && p.getExitAltitude() == p.getAltitude()) { this.successfulExits++; succ = true; break; } if (succ) succ = false; else this.unsuccessfulExits++; remover.add(p.getID()); } } for (Character id : remover) backBuffer.remove(id); // Remover avi�es que colidiram no epoch anterior - est�o marcados com um '+' for (Plane p : frontBuffer.values()) if (p.getSymbol() == '+') { backBuffer.remove(p.getID()); this.unsuccessfulExits++; } // Testar colis�es for (Plane p : backBuffer.values()) { x = p.getxCoord(); y = p.getyCoord(); for (Plane p2 : backBuffer.values()) { int x2 = p2.getxCoord(); int y2 = p2.getyCoord(); if (p != p2 && Math.abs(x - x2) <= 1 && Math.abs(y - y2) <= 1 && Math.abs(p.getAltitude() - p2.getAltitude()) <= 1000) { p.setSymbol('+'); p2.setSymbol('+'); } // N�o fazer 'continue;' pq pode haver 3 ou mais avi�es a colidirem } } // Reset avioes adicionados previousAdds = actualAdds; actualAdds = new HashMap<Gate, Integer>(); // Trocar os buffers epoch++; swapBuffers(); }
@Override protected void onDraw(Canvas canvas) { Move m = board.getLastMovew(); // Background canvas.drawColor(colBackground); Paint myPen = new Paint(); for (int r = 0; r <= board.getHeight(); r++) { drawLine( LEFT_MARGIN - position_x, (TOP_MARGIN + r * CELL_HEIGHT) - position_y, (LEFT_MARGIN + board.getWidth() * CELL_WIDTH) - position_x, (TOP_MARGIN + r * CELL_HEIGHT) - position_y, canvas, myPen); } for (int c = 0; c <= board.getWidth(); c++) { drawLine( (LEFT_MARGIN + c * CELL_WIDTH) - position_x, TOP_MARGIN - position_y, (LEFT_MARGIN + c * CELL_WIDTH) - position_x, (TOP_MARGIN + board.getHeight() * CELL_HEIGHT) - position_y, canvas, myPen); } myPen.setColor(colBorder); myPen.setStrokeWidth(3); canvas.drawRect( LEFT_MARGIN - position_x, TOP_MARGIN - position_y, LEFT_MARGIN + board.getWidth() * CELL_WIDTH - position_x, (TOP_MARGIN + board.getHeight() * CELL_HEIGHT) - position_y, myPen); for (int r = 0; r < board.getHeight(); r++) { for (int c = 0; c < board.getWidth(); c++) { int x_in = 0, y_in = 0; if (m != null) { x_in = (int) ((m.getColumn() - c) / (float) board.getWidth() * PIECE_WIDTH); y_in = (int) ((m.getRow() - r) / (float) board.getWidth() * PIECE_HEIGHT); x_in = (x_in > PIECE_WIDTH / 2) ? PIECE_WIDTH / 2 : x_in; y_in = (y_in > PIECE_HEIGHT / 2) ? PIECE_HEIGHT / 2 : y_in; } byte piece = board.getPiece(r, c); if (piece == Board.WHITE) { if (board.lastmovew(new Move(r, c, Board.WHITE))) { drawWhiteLast( LEFT_MARGIN - position_x + c * CELL_WIDTH + (CELL_WIDTH - PIECE_WIDTH) / 2, TOP_MARGIN - position_y + r * CELL_HEIGHT + (CELL_HEIGHT - PIECE_HEIGHT) / 2, canvas); } else { drawShadowWhite( LEFT_MARGIN - position_x + c * CELL_WIDTH + (CELL_WIDTH - PIECE_WIDTH) / 2 - x_in, TOP_MARGIN - position_y + r * CELL_HEIGHT + (CELL_HEIGHT - PIECE_HEIGHT) / 2 - y_in, canvas); drawWhite( LEFT_MARGIN - position_x + c * CELL_WIDTH + (CELL_WIDTH - PIECE_WIDTH) / 2, TOP_MARGIN - position_y + r * CELL_HEIGHT + (CELL_HEIGHT - PIECE_HEIGHT) / 2, canvas); } } if (piece == Board.BLACK) { if (board.lastmovew(new Move(r, c, Board.BLACK))) { drawBlackLast( LEFT_MARGIN - position_x + c * CELL_WIDTH + (CELL_WIDTH - PIECE_WIDTH) / 2, TOP_MARGIN - position_y + r * CELL_HEIGHT + (CELL_HEIGHT - PIECE_HEIGHT) / 2, canvas); } else { drawShadowBlack( LEFT_MARGIN - position_x + c * CELL_WIDTH + (CELL_WIDTH - PIECE_WIDTH) / 2 - x_in, TOP_MARGIN - position_y + r * CELL_HEIGHT + (CELL_HEIGHT - PIECE_HEIGHT) / 2 - y_in, canvas); drawBlack( LEFT_MARGIN - position_x + c * CELL_WIDTH + (CELL_WIDTH - PIECE_WIDTH) / 2, TOP_MARGIN - position_y + r * CELL_HEIGHT + (CELL_HEIGHT - PIECE_HEIGHT) / 2, canvas); } } } } if (m != null) { drawHigh( LEFT_MARGIN - position_x + m.getColumn() * CELL_WIDTH + (CELL_WIDTH - PIECE_WIDTH) / 2, TOP_MARGIN - position_y + m.getRow() * CELL_HEIGHT + (CELL_HEIGHT - PIECE_HEIGHT) / 2, canvas); } if (mButtonPressed == true) { if (celltouch.x < board.getWidth() && celltouch.y < board.getHeight() /*&&board.getPiece(celltouch.x,celltouch.y)==Board.BLACK*/) { myPen.setColor(colSelect); myPen.setStrokeWidth(3); myPen.setStyle(Paint.Style.STROKE); canvas.drawRect( LEFT_MARGIN - position_x + celltouch.x * CELL_WIDTH, TOP_MARGIN - position_y + celltouch.y * CELL_WIDTH, LEFT_MARGIN - position_x + (celltouch.x + 1) * CELL_WIDTH, TOP_MARGIN - position_y + (celltouch.y + 1) * CELL_HEIGHT, myPen); } } super.onDraw(canvas); }