private Action scanArenaColByCol(Robot robot) { Action actionForTentativeTurn = actionForTentiveTurn(robot); if (actionForTentativeTurn != null) return actionForTentativeTurn; if (robotOnArenaEdge(robot, headingOrientation)) { Orientation current = robot.getCurrentOrientation(); if (!current.toOppsite().equals(headingOrientation)) { return Action.TURN_LEFT; } else { headingOrientation = headingOrientation.toOppsite(); trackColID += robot.getDiameterInCellNum(); // Whole arena has been explored if (trackColID >= this.exploredMap.getColumnCount()) return null; } } int currentSouthWestColID = robot.getSouthWestBlock().getColID(); if (currentSouthWestColID < trackColID) { return moveToOrientation(robot, Orientation.EAST, headingOrientation); } else if (currentSouthWestColID == trackColID) { return moveToOrientation(robot, headingOrientation, Orientation.EAST); } else { // currentSouthWestColID > trackColID return moveToOrientation(robot, Orientation.WEST, headingOrientation); } }
private Action moveToOrientation( Robot robot, Orientation firstOrientation, Orientation secondOrientation) { Direction preferedDirection = getPreferedDirection(firstOrientation, secondOrientation); Orientation currentOrientation = robot.getCurrentOrientation(); // System.out.println("Current Orientation = " + currentOrientation.toString()); // System.out.println("First Orientation = " + firstOrientation.toString()); // System.out.println("Second Orientation = " + secondOrientation.toString()); if (currentOrientation.equals(firstOrientation)) { return moveTowardsDirectionInOrder( Direction.AHEAD, preferedDirection, oppoDirection(preferedDirection), robot); } else if (currentOrientation.equals(secondOrientation)) { return moveTowardsDirectionInOrder( oppoDirection(preferedDirection), Direction.AHEAD, preferedDirection, robot); } else if (currentOrientation.toOppsite().equals(firstOrientation)) { return moveTowardsDirectionInOrder( oppoDirection(preferedDirection), Direction.AHEAD, preferedDirection, robot); } else if (currentOrientation.toOppsite().equals(secondOrientation)) { return moveTowardsDirectionInOrder( preferedDirection, Direction.AHEAD, oppoDirection(preferedDirection), robot); } assert (false) : "Should not reach here. No other circumstance"; return null; }
void advance() { do { x += o.getDx(); y += o.getDy(); } while (!game.getBoard().getTile(y, x).equals(Tile.NONE) || placedTiles.get(new Point(x, y)) != null); }
/** @param name The new name of the units. Defaults to DEFAULT is there is no match. */ public void setOrientation(String name) { for (Orientation orientation : Orientation.values()) { if (orientation.getName().equals(name)) { this.orientation = orientation; return; } } this.orientation = Orientation.DEFAULT; }
private boolean existsCellOnOrientaion(Robot robot, Orientation ori, CellState state) { Boolean needExplore = null; if (robotOnArenaEdge(robot, ori)) return false; if (ori.equals(Orientation.NORTH)) needExplore = existsCellOnTheNorth(robot, state); if (ori.equals(Orientation.WEST)) needExplore = existsCellOnTheWest(robot, state); if (ori.equals(Orientation.SOUTH)) needExplore = existsCellOnTheSouth(robot, state); if (ori.equals(Orientation.EAST)) needExplore = existsCellOnTheEast(robot, state); return needExplore; }
// Return the new orientation based on the original orientation and its relative direction private static Orientation orientationOnDirection(Orientation original, Direction direction) { if (direction == Direction.AHEAD) { return original.clone(); } else if (direction == Direction.LEFT) { return original.relativeToLeft(); } else if (direction == Direction.RIGHT) { return original.relativeToRight(); } else { assert (false) : "Should not reach here"; } return null; }
private Direction getPreferedDirection( Orientation firstOrientation, Orientation secondOrientation) { Direction preferedDirection = Direction.NULL; if (firstOrientation.relativeToLeft().equals(secondOrientation)) { preferedDirection = Direction.LEFT; } else if (firstOrientation.relativeToRight().equals(secondOrientation)) { preferedDirection = Direction.RIGHT; } else { assert (false) : "Two Prefered Orientation should be adjacent"; } return preferedDirection; }
public void move() { if (last_move_time == null || last_move_time.doubleValue() < world.time) { last_move_time = new Double(world.time); double max_dist, dist_right, dist_left, theta, x, y, dist_diff; double delta_theta, turn_radius, new_theta, new_x, new_y; Location location; Orientation orientation; orientation = orientation(); location = location(); max_dist = max_speed / world.ticks_per_second; dist_right = right_motor.output() * max_dist; dist_left = left_motor.output() * max_dist; theta = orientation.theta; x = location.x; y = location.y; old_location.x = x; old_location.y = y; dist_diff = dist_right - dist_left; // System.out.println("dist_diff: " + dist_diff); delta_theta = dist_diff / wheel_base; if (Math.abs(dist_diff) < .0001) { turn_radius = 0.0; } else { turn_radius = (dist_right / delta_theta) - (wheel_base / 2); } // System.out.println("turn_radius: " + turn_radius); new_theta = theta + delta_theta; if (turn_radius == 0.0) { // System.out.println("turn_radius == 0"); new_x = x + Math.cos(theta) * dist_left; new_y = y + Math.sin(theta) * dist_left; } else { // System.out.println("new_theta= " + new_theta + " theta= " + theta); new_x = x + ((Math.sin(new_theta) - Math.sin(theta)) * turn_radius); new_y = y - ((Math.cos(new_theta) - Math.cos(theta)) * turn_radius); } orientation.theta = new_theta; location.x = new_x; location.y = new_y; maybe_fire_guns(); } }
public static void setOrientation(Element el, Orientation value) { // iOS6 & Android < 4.4 switch (value) { case HORIZONTAL: el.getStyle().setProperty("WebkitBoxOrient", "horizontal"); break; case VERTICAL: el.getStyle().setProperty("WebkitBoxOrient", "vertical"); break; default: throw new RuntimeException(); } setFlexProperty(el, Orientation.getCssProperty(), value.getCssValue()); }
private void init(Context context, AttributeSet attrs, int defStyle) { TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.IncreasingSeekBar, defStyle, 0); try { mOrientation = Orientation.fromId( typedArray.getInt( R.styleable.IncreasingSeekBar_isb_orientation, Orientation.HORIZONTAL.id)); mMaxRang = typedArray.getInt(R.styleable.IncreasingSeekBar_isb_max, DEF_MAX_RANG); mCurrValue = typedArray.getInt(R.styleable.IncreasingSeekBar_isb_curr_value, 0); mGapWidthPercent = typedArray.getFraction( R.styleable.IncreasingSeekBar_isb_gap_percent, 1, 1, DEF_GAP_PERCENT); mAllowUserTouch = typedArray.getBoolean(R.styleable.IncreasingSeekBar_isb_allow_user_touch, true); mDrawBorder = typedArray.getBoolean(R.styleable.IncreasingSeekBar_isb_draw_border, false); mBorderColor = typedArray.getColor(R.styleable.IncreasingSeekBar_isb_border_color, DEF_COLOR); mBorderWidth = typedArray.getDimension(R.styleable.IncreasingSeekBar_isb_border_width, DEF_BORDER_WIDTH); mMainColor = typedArray.getColor(R.styleable.IncreasingSeekBar_isb_color, DEF_COLOR); mStartColor = typedArray.getColor(R.styleable.IncreasingSeekBar_isb_color_start, -1); mEndColor = typedArray.getColor(R.styleable.IncreasingSeekBar_isb_color_end, -1); } finally { typedArray.recycle(); } mBarItemPaint = new Paint(Paint.ANTI_ALIAS_FLAG); mBarItemPaint.setColor(mMainColor); mBorderPaint = new Paint(Paint.ANTI_ALIAS_FLAG); mBorderPaint.setStyle(Paint.Style.STROKE); mBorderPaint.setStrokeWidth(mBorderWidth); mBarItemPaint.setColor(mBorderColor); }
public static Orientation fromIndex(int index) { Orientation[] values = Orientation.values(); if (index < 0 || index >= values.length) { throw new IndexOutOfBoundsException(); } return values[index]; }
@Override public JComponent createUI( DescriptionType inputOrOutput, Map<URI, Object> dataMap, Orientation orientation) { // Create the main panel JComponent component = new JPanel(new MigLayout("fill")); boolean isOptional = false; if (inputOrOutput instanceof InputDescriptionType) { isOptional = ((InputDescriptionType) inputOrOutput).getMinOccurs().equals(new BigInteger("0")); } // Display the SourceCA into a JTextField JTextField jtf = new JTextField(); jtf.setToolTipText(inputOrOutput.getAbstract().get(0).getValue()); // "Save" the CA inside the JTextField jtf.getDocument().putProperty(DATA_MAP_PROPERTY, dataMap); URI uri = URI.create(inputOrOutput.getIdentifier().getValue()); jtf.getDocument().putProperty(URI_PROPERTY, uri); // add the listener for the text changes in the JTextField jtf.getDocument() .addDocumentListener( EventHandler.create(DocumentListener.class, this, "saveDocumentText", "document")); if (isOptional) { if (dataMap.containsKey(uri)) { jtf.setText(dataMap.get(uri).toString()); } } GeometryData geometryData = null; if (inputOrOutput instanceof InputDescriptionType) { geometryData = (GeometryData) ((InputDescriptionType) inputOrOutput).getDataDescription().getValue(); } // If the DescriptionType is an output, there is nothing to show, so exit if (geometryData == null) { return null; } component.add(jtf, "growx"); if (orientation.equals(Orientation.VERTICAL)) { JPanel buttonPanel = new JPanel(new MigLayout()); // Create the button Browse JButton pasteButton = new JButton(ToolBoxIcon.getIcon(ToolBoxIcon.PASTE)); // "Save" the sourceCA and the JTextField in the button pasteButton.putClientProperty(TEXT_FIELD_PROPERTY, jtf); pasteButton.setBorderPainted(false); pasteButton.setContentAreaFilled(false); pasteButton.setMargin(new Insets(0, 0, 0, 0)); // Add the listener for the click on the button pasteButton.addActionListener(EventHandler.create(ActionListener.class, this, "onPaste", "")); buttonPanel.add(pasteButton); component.add(buttonPanel, "dock east"); } return component; }
private boolean robotOnArenaEdge(Robot robot, Orientation ori) { if (ori.equals(Orientation.NORTH)) { return robot.getSouthWestBlock().getRowID() == robot.getDiameterInCellNum() - 1; } if (ori.equals(Orientation.EAST)) { return robot.getSouthWestBlock().getColID() == this.exploredMap.getColumnCount() - robot.getDiameterInCellNum(); } if (ori.equals(Orientation.SOUTH)) { return robot.getSouthWestBlock().getRowID() == this.exploredMap.getRowCount() - 1; } if (ori.equals(Orientation.WEST)) { return robot.getSouthWestBlock().getColID() == 0; } assert (false) : "No other direction..."; return false; }
private boolean contains(Node x, Point2D p, Orientation orientation) { if (x == null) { return false; } if (x.p.equals(p)) { return true; } int cmp = compare(p, x.p, orientation); Orientation nextOrientation = orientation.next(); if (cmp < 0) { return contains(x.lb, p, nextOrientation); } else { return contains(x.rt, p, nextOrientation); } }
private Point2D findNearest( Node x, Point2D p, Point2D nearest, double minDist, Orientation orientation) { if (x == null) { return nearest; } Point2D closest = nearest; double closestDistance = minDist; double distance = x.p.distanceSquaredTo(p); if (distance < minDist) { closest = x.p; closestDistance = distance; } Node first, second; if (orientation == Orientation.LR) { if (p.x() < x.p.x()) { first = x.lb; second = x.rt; } else { first = x.rt; second = x.lb; } } else { if (p.y() < x.p.y()) { first = x.lb; second = x.rt; } else { first = x.rt; second = x.lb; } } Orientation nextOrientation = orientation.next(); if (first != null && first.rect.distanceSquaredTo(p) < closestDistance) { closest = findNearest(first, p, closest, closestDistance, nextOrientation); closestDistance = closest.distanceSquaredTo(p); } if (second != null && second.rect.distanceSquaredTo(p) < closestDistance) { closest = findNearest(second, p, closest, closestDistance, nextOrientation); } return closest; }
@Override public void onBeginParsing( String orientation, Color backgroundColor, int width, int height, int tileWidth, int tileHeight) { try { this.orientation = Orientation.valueOf(orientation.toUpperCase()); } catch (Exception e) { this.orientation = Orientation.UNKNOWN; } if (backgroundColor != null) { this.backgroundColor = backgroundColor; } this.width = width; this.height = height; this.tileWidth = tileWidth; this.tileHeight = tileHeight; }
private void renderCupola(CupolaTE te) { if (te.isSlave()) return; final Tessellator instance = Tessellator.getInstance(); final BlockPos pos = te.getPos(); final World world = te.getWorld(); // Lighting final float brightness = ModBlock.cupola.getMixedBrightnessForBlock(world, pos); final int skyLight = world.getLightBrightnessForSkyBlocks(pos, 0); final int skyLightLSB = skyLight % 65536; final int skyLightMSB = skyLight / 65536; final WorldRenderer worldRenderer = instance.getWorldRenderer(); worldRenderer.setColorOpaque_F(brightness, brightness, brightness); OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, skyLightLSB, skyLightMSB); // Open Render buffer GL11.glPushMatrix(); // Inherent adjustments to model GL11.glScalef(SCALE.left, SCALE.middle, SCALE.right); GL11.glTranslatef(OFFSET.left, OFFSET.middle, OFFSET.right); // Orient the model to match the placement final IBlockState metadata = world.getBlockState(pos); final Orientation orientation = Orientation.getdecodedOrientation(metadata); GL11.glRotatef(getAngleFromOrientation(orientation), 0.0F, 1.0F, 0.0F); // Bind the texture if (te.isActive()) bindTexture(TEXTURE_ACTIVE); else bindTexture(TEXTURE); // Render model.render(); // Close Render Buffer GL11.glPopMatrix(); }
public void init() { assert name != null; assert type != null; assert legend != null; assert database != null; assert query != null; try { actualType = Type.valueOf(type); generatorClass = actualType.getGeneratorClass(); } catch (Exception e) { logger.error("Invalid chart type: " + type, e); } if (orientation != null) { try { actualOrientation = Orientation.valueOf(orientation); } catch (Exception e) { logger.error("Invalid orientation: " + actualOrientation, e); } } actualDatabase = DatabaseLogic.findDatabaseByName(persistence.getModel(), database); }
private void draw(Node x, Orientation orientation) { if (x == null) { return; } StdDraw.setPenColor(StdDraw.BLACK); StdDraw.setPenRadius(0.01); x.p.draw(); if (orientation == Orientation.LR) { StdDraw.setPenColor(StdDraw.RED); StdDraw.setPenRadius(0.001); StdDraw.line(x.p.x(), x.rect.ymin(), x.p.x(), x.rect.ymax()); } else { StdDraw.setPenColor(StdDraw.BLUE); StdDraw.setPenRadius(0.001); StdDraw.line(x.rect.xmin(), x.p.y(), x.rect.xmax(), x.p.y()); } Orientation next = orientation.next(); draw(x.lb, next); draw(x.rt, next); }
private Node put(Node x, Point2D p, Orientation orientation) { if (x == null) { ++size; return new Node(p); } if (x.p.equals(p)) { return x; } int cmp = compare(p, x.p, orientation); Orientation nextOrientation = orientation.next(); if (cmp < 0) { x.lb = put(x.lb, p, nextOrientation); if (x.lb.rect == null) { if (orientation == Orientation.LR) { x.lb.rect = new RectHV(x.rect.xmin(), x.rect.ymin(), x.p.x(), x.rect.ymax()); } else { x.lb.rect = new RectHV(x.rect.xmin(), x.rect.ymin(), x.rect.xmax(), x.p.y()); } } } else { x.rt = put(x.rt, p, nextOrientation); if (x.rt.rect == null) { if (orientation == Orientation.LR) { x.rt.rect = new RectHV(x.p.x(), x.rect.ymin(), x.rect.xmax(), x.rect.ymax()); } else { x.rt.rect = new RectHV(x.rect.xmin(), x.p.y(), x.rect.xmax(), x.rect.ymax()); } } } return x; }
private static void createAndShowGUI() { JFrame frame = new JFrame("Fractal"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); SpringLayout layout = new SpringLayout(); frame.setLayout(layout); Orientation nw = new Orientation(); nw.setOffset(0, 0); Orientation sw = new Orientation(); sw.setOffset(0, regionSize); Orientation se = new Orientation(); se.setOffset(regionSize, regionSize); Fractal fractal = new Fractal(regionSize); fractal.setOrientations(nw, sw, se); layout.putConstraint(SpringLayout.WEST, fractal, 5, SpringLayout.WEST, frame.getContentPane()); layout.putConstraint( SpringLayout.NORTH, fractal, 5, SpringLayout.NORTH, frame.getContentPane()); layout.putConstraint(SpringLayout.WEST, nw, 5, SpringLayout.EAST, fractal); layout.putConstraint(SpringLayout.NORTH, nw, 0, SpringLayout.NORTH, fractal); layout.putConstraint(SpringLayout.NORTH, sw, 5, SpringLayout.SOUTH, nw); layout.putConstraint(SpringLayout.WEST, sw, 0, SpringLayout.WEST, nw); layout.putConstraint(SpringLayout.NORTH, se, 5, SpringLayout.SOUTH, nw); layout.putConstraint(SpringLayout.WEST, se, 5, SpringLayout.EAST, sw); layout.putConstraint( SpringLayout.SOUTH, frame.getContentPane(), 5, SpringLayout.SOUTH, fractal); layout.putConstraint(SpringLayout.EAST, frame.getContentPane(), 5, SpringLayout.EAST, se); frame.add(nw); frame.add(sw); frame.add(se); frame.add(fractal); frame.setResizable(false); frame.pack(); frame.setVisible(true); }
/** * Converts the video orientation into the byte used to transmit int RTP header * * @return Byte representing the video orientation */ public byte getVideoOrientation() { return (byte) ((camera.getValue() << 3) | orientation.getValue()); }
/** * Parses the byte into a VideoOrientation object * * @param videoOrientation Byte representing the video Orientation * @return VideoOrientation object */ public static VideoOrientation parse(byte videoOrientation) { return new VideoOrientation( CameraOptions.convert((videoOrientation & 0x08) >>> 3), Orientation.convert(videoOrientation & 0x07)); }
/** @return the orientation option value */ public Orientation getOrientation() { String orientation = this.options.getLiteral("orientation"); return orientation == null ? Orientation.HORIZONTAL : Orientation.valueOf(orientation.toUpperCase()); }
private void drawTile(IBoard b, GC gc, int x, int y, int xo, int yo, int size) { gc.setClipping(xo, yo, size + 1, size + 1); Color c = background; if (b.getLetterMultiplier(y, x) == 2) c = doubleLetter; else if (b.getLetterMultiplier(y, x) == 3) c = tripleLetter; else if (b.getLetterMultiplier(y, x) == 4) c = quadLetter; else if (b.getWordMultiplier(y, x) == 2) c = doubleWord; else if (b.getWordMultiplier(y, x) == 3) c = tripleWord; else if (b.getWordMultiplier(y, x) == 4) c = quadWord; gc.setBackground(c); gc.fillRectangle(xo, yo, size, size); c = light; if (b.getLetterMultiplier(y, x) == 2) c = doubleLetterLight; else if (b.getLetterMultiplier(y, x) == 3) c = tripleLetterLight; else if (b.getLetterMultiplier(y, x) == 4) c = quadLetterLight; else if (b.getWordMultiplier(y, x) == 2) c = doubleWordLight; else if (b.getWordMultiplier(y, x) == 3) c = tripleWordLight; else if (b.getWordMultiplier(y, x) == 4) c = quadWordLight; gc.setForeground(c); gc.drawLine(xo, yo, xo + size, yo); gc.drawLine(xo, yo, xo, yo + size); gc.setForeground(dark); gc.drawLine(xo + size, yo + size, xo + size, yo); gc.drawLine(xo + size, yo + size, xo, yo + size); Tile tile = b.getTile(y, x); if (tile.equals(Tile.NONE)) { for (Iterator i = placedTiles.entrySet().iterator(); i.hasNext(); ) { Map.Entry entry = (Map.Entry) i.next(); Point point = (Point) entry.getKey(); if (point.x == x && point.y == y) { tile = (Tile) entry.getValue(); DragSource source = new DragSource(); source.rectangle = new Rectangle(xo, yo, size + 1, size + 1); source.x = x; source.y = y; source.tile = tile; dragSources.put(source.rectangle, source); } } } boolean highlight = false; IGameAction action = game.getLastAction(); if (action != null && action instanceof MoveAction) { MoveAction moveAction = (MoveAction) action; MoveResult result = moveAction.getMoveResult(); Tile[] tiles = result.getPreviousBoardState(); Move move = result.getMove(); Orientation orientation = move.getOrientation(); int dx = orientation.getDx(); int dy = orientation.getDy(); int mx = move.getColumn(); int my = move.getRow(); for (int i = 0; i < tiles.length; i++) { Tile t = tiles[i]; if (mx == x && my == y && t.equals(Tile.NONE)) { highlight = true; } mx += dx; my += dy; } } drawTile(gc, new Rectangle(xo, yo, size + 1, size + 1), tile, highlight); if (arrow != null && arrow.x == x && arrow.y == y) { drawArrow(gc, xo, yo, size); } }
/** * Normally you don't need to set this option because the plugin detects the slider orientation * automatically. If the orientation is not correctly detected you can set this option to * 'horizontal' or 'vertical'. * * @param orientation * @return instance of the current component */ public Slider setOrientation(Orientation orientation) { this.options.putLiteral("orientation", orientation.toString().toLowerCase()); return this; }
void backup() { do { x -= o.getDx(); y -= o.getDy(); } while (!game.getBoard().getTile(y, x).equals(Tile.NONE)); }
private void majgrid1(Player player) { gridtest = new Grid(); gridtest = player.getGridJoueur(); ShipType type = ShipType.AIRCRAFT_CARRIER; Ship ship = new Ship(type); Orientation orient = Orientation.HORIZONTAL; for (int i = 0; i < 10; i++) // ligne { for (int j = 0; j < 10; j++) // colonne { if (gridtest.getCell(i, j) instanceof OceanCell) { tabbout1[i][j].setIcon(iconeau); } // else if(gridtest.getCell(i, j) instanceof TouchOceanCell) // { // tabbout1[i][j].setIcon(iconeautouch); // } // else if(gridtest.getCell(i, j) instanceof TouchOceanCell) // { // tabbout1[i][j].setIcon(icondebristouch); // } else if (gridtest.getCell(i, j) instanceof ShipCell) { ship = ((ShipCell) gridtest.getCell(i, j)).getShip(); int size = ship.getSize(); orient = ((ShipCell) gridtest.getCell(i, j)).getOrient(); if (orient.isHorizontal()) { if (ship.getSize() == 2) { tabbout1[i][j].setIcon(iconsub1h); tabbout1[i][j + 1].setIcon(iconsub2h); tabbout1[i][j + 2].setIcon(iconsub3h); j = j + 2; } else if (ship.getSize() == 3) // battleship { tabbout1[i][j].setIcon(iconbattle1h); tabbout1[i][j + 1].setIcon(iconbattle2h); tabbout1[i][j + 2].setIcon(iconbattle3h); tabbout1[i][j + 3].setIcon(iconbattle4h); j = j + 3; } else { tabbout1[i][j].setIcon(iconair1h); tabbout1[i][j + 1].setIcon(iconair2h); tabbout1[i][j + 2].setIcon(iconair3h); tabbout1[i][j + 3].setIcon(iconair4h); tabbout1[i][j + 4].setIcon(iconair5h); j = j + 4; } } } } for (int i2 = 0; i2 < 10; i2++) // ligne { for (int j2 = 0; j2 < 10; j2++) // colonne { if (gridtest.getCell(i2, j2) instanceof ShipCell) { ship = ((ShipCell) gridtest.getCell(i2, j2)).getShip(); orient = ((ShipCell) gridtest.getCell(i2, j2)).getOrient(); if (!orient.isHorizontal()) { if (ship.getSize() == 2) { tabbout1[i2][j2].setIcon(iconsub1v); tabbout1[i2 + 1][j2].setIcon(iconsub2v); tabbout1[i2 + 2][j2].setIcon(iconsub3v); i2 = i2 + 2; } else if (ship.getSize() == 3) // battleship { tabbout1[i2][j2].setIcon(iconbattle1v); tabbout1[i2 + 1][j2].setIcon(iconbattle2v); tabbout1[i2 + 2][j2].setIcon(iconbattle3v); tabbout1[i2 + 3][j2].setIcon(iconbattle4v); i2 = i2 + 3; } else { tabbout1[i2][j2].setIcon(iconair1v); tabbout1[i2 + 1][j2].setIcon(iconair2v); tabbout1[i2 + 2][j2].setIcon(iconair3v); tabbout1[i2 + 3][j2].setIcon(iconair4v); tabbout1[i2 + 4][j2].setIcon(iconair5v); i2 = i2 + 4; } } } } } } }
public Vector_2 perpendicular(Orientation o) { if (o.isCounterclockwise() == true) return new Vector_2(-y, x); else return new Vector_2(y, -x); }
// create move based on placed tiles private Move createMove() { if (game == null) return null; if (placedTiles.size() < 1) return null; Point[] points = new Point[placedTiles.size()]; placedTiles.keySet().toArray(points); IBoard board = game.getBoard(); boolean horizontal = true; boolean vertical = true; // vertical? for (int i = 1; i < points.length; i++) { Point point = points[i]; if (point.x != points[i - 1].x) { vertical = false; break; } } // horizontal? for (int i = 1; i < points.length; i++) { Point point = points[i]; if (point.y != points[i - 1].y) { horizontal = false; break; } } // scattered and invalid? if (!horizontal && !vertical) { return null; } // ambiguous? if (horizontal && vertical) { int x = points[0].x; int y = points[0].y; if (board.getTile(y, x - 1).equals(Tile.NONE) && board.getTile(y, x + 1).equals(Tile.NONE)) { horizontal = false; } if (board.getTile(y - 1, x).equals(Tile.NONE) && board.getTile(y + 1, x).equals(Tile.NONE)) { vertical = false; } // not adjacent to anything? if (!horizontal && !vertical) { return null; } // still ambiguous? if (horizontal && vertical) { // just pick one horizontal = false; } } Orientation orientation = vertical ? Orientation.VERTICAL : Orientation.HORIZONTAL; int dx = orientation.getDx(); int dy = orientation.getDy(); // find first placed tile int x = points[0].x; int y = points[0].y; for (int i = 1; i < points.length; i++) { Point point = points[i]; if (point.x < x) x = point.x; if (point.y < y) y = point.y; } // traverse on-board tiles backwards while (!board.getTile(y - dy, x - dx).equals(Tile.NONE)) { x -= dx; y -= dy; } int row = y; int column = x; // build word StringBuffer b = new StringBuffer(); while (true) { Point point = new Point(x, y); Tile tile = board.getTile(y, x); if (tile == null || tile.equals(Tile.NONE)) { tile = placedTiles.get(point); } if (tile == null || tile.equals(Tile.NONE)) { break; } b.append(tile); x += dx; y += dy; } Move move = new Move(); move.setColumn(column); move.setRow(row); move.setOrientation(orientation); move.setWord(Convert.toTiles(b.toString())); return move; }