@Override public void onBulletHitBullet(BulletHitBulletEvent event) { Point2D bulletPosition = new Point2D.Double(event.getBullet().getX(), event.getBullet().getY()); GBulletFiredEvent hittedWave = null; for (GBulletFiredEvent wave : waves.getWaves()) { if (Math.abs( bulletPosition.distance(wave.getFiringPosition()) - ((getTime() - wave.getFiringTime()) * event.getBullet().getVelocity())) < 20) { hittedWave = wave; break; } } if (hittedWave == null) return; double firingOffset = org.pattern.utils.Utils.firingOffset( hittedWave.getFiringPosition(), hittedWave.getTargetPosition(), bulletPosition); double mae = firingOffset > 0 ? hittedWave.getMaxMAE() : hittedWave.getMinMAE(); double gf = firingOffset > 0 ? firingOffset / mae : -firingOffset / mae; storages.get(event.getBullet().getName()).visit(gf); waves.getWaves().remove(hittedWave); return; }
/** * Constructs a <code>LinearGradientPaint</code>. * * @param start the gradient axis start <code>Point</code> in user space * @param end the gradient axis end <code>Point</code> in user space * @param fractions numbers ranging from 0.0 to 1.0 specifying the distribution of colors along * the gradient * @param colors array of colors corresponding to each fractional value * @param cycleMethod either NO_CYCLE, REFLECT, or REPEAT * @param colorSpace which colorspace to use for interpolation, either SRGB or LINEAR_RGB * @param gradientTransform transform to apply to the gradient * @throws NullPointerException if one of the points is null, or gradientTransform is null * @throws IllegalArgumentException if start and end points are the same points, or if * fractions.length != colors.length, or if colors is less than 2 in size. */ public LinearGradientPaint( Point2D start, Point2D end, float[] fractions, Color[] colors, CycleMethodEnum cycleMethod, ColorSpaceEnum colorSpace, AffineTransform gradientTransform) { super(fractions, colors, cycleMethod, colorSpace, gradientTransform); // // Check input parameters // if (start == null || end == null) { throw new NullPointerException("Start and end points must be" + "non-null"); } if (start.equals(end)) { throw new IllegalArgumentException("Start point cannot equal" + "endpoint"); } // copy the points... this.start = (Point2D) start.clone(); this.end = (Point2D) end.clone(); }
public static BufferedImage rotateImage(BufferedImage image, double theta) { int degrees = (int) Math.abs(Math.toDegrees(theta)); double xCenter = image.getWidth() / 2; double yCenter = image.getHeight() / 2; AffineTransform rotateTransform = AffineTransform.getRotateInstance(-theta, xCenter, yCenter); // Translation adjustments so image still centered after rotate width/height changes if (image.getHeight() != image.getWidth() && degrees != 180 && degrees != 0) { Point2D origin = new Point2D.Double(0.0, 0.0); origin = rotateTransform.transform(origin, null); double yTranslate = origin.getY(); Point2D yMax = new Point2D.Double(0, image.getHeight()); yMax = rotateTransform.transform(yMax, null); double xTranslate = yMax.getX(); AffineTransform translationAdjustment = AffineTransform.getTranslateInstance(-xTranslate, -yTranslate); rotateTransform.preConcatenate(translationAdjustment); } AffineTransformOp op = new AffineTransformOp(rotateTransform, AffineTransformOp.TYPE_BILINEAR); // Have to recopy image because of JDK bug #4723021, AffineTransformationOp throwing exception // sometimes image = copyImage(image, BufferedImage.TYPE_INT_ARGB); // Need to create filter dest image ourselves since AffineTransformOp's own dest image creation // throws exceptions in some cases. Rectangle bounds = op.getBounds2D(image).getBounds(); BufferedImage finalImage = new BufferedImage( (int) bounds.getWidth(), (int) bounds.getHeight(), BufferedImage.TYPE_INT_ARGB); return op.filter(image, finalImage); }
/** Force this handle to relocate itself using its locator. */ public void relocateHandle() { if (locator != null) { final PBounds b = getBoundsReference(); final Point2D aPoint = locator.locatePoint(null); if (locator instanceof PNodeLocator) { final PNode located = ((PNodeLocator) locator).getNode(); final PNode parent = getParent(); located.localToGlobal(aPoint); globalToLocal(aPoint); if (parent != located && parent instanceof PCamera) { ((PCamera) parent).viewToLocal(aPoint); } } final double newCenterX = aPoint.getX(); final double newCenterY = aPoint.getY(); if (newCenterX != b.getCenterX() || newCenterY != b.getCenterY()) { centerBoundsOnPoint(newCenterX, newCenterY); } } }
private void doMovement() { Point2D actualPosition = new Point2D.Double(getX(), getY()); if (nextPosition == null) nextPosition = actualPosition; if (corner) { goToCorner(); out.println("corner"); } else if (nextPosition == null || nextPosition.equals(actualPosition) || nextPosition.distance(actualPosition) < 15) { try { // PositionFinder f = new PositionFinder(enemies, this); // nextPosition = f.generateRandomPoint(); // nextPosition = f.findBestPointInRangeWithRandomOffset(500); gotoPointandSmooth(); } catch (Exception e) { System.out.println(e); } } else { gotoPointandSmooth(); } lastPosition = actualPosition; }
public int compare(Point2D left, Point2D right) { if (left.getX() < right.getX()) return -1; if (left.getX() > right.getX()) return 1; if (left.getY() < right.getY()) return -1; if (left.getY() > right.getY()) return 1; return 0; }
/** * returns a point that is a google tile reference for the tile containing the lat/lng and at the * zoom level. * * @param lat * @param lng * @param zoom * @return */ public static Point toTileXY(double lat, double lng, int zoom) { Point2D normalised = toNormalisedPixelCoords(lat, lng); int scale = 1 << zoom; // can just truncate to integer, this looses the fractional "pixel offset" return new Point((int) (normalised.getX() * scale), (int) (normalised.getY() * scale)); }
public void drawGame() { StdDraw.clear(StdDraw.GRAY); // Set Color StdDraw.setPenColor(StdDraw.YELLOW); // Set Font setFont(new Font("SansSerif", Font.PLAIN, 32)); // X, Y, String, rotation degree // Write String this.text(1 - 0.3, 1 - 0.1, blockP.x + ", " + blockP.y, 0); // Set Color StdDraw.setPenColor(StdDraw.ORANGE); // Set Font setFont(new Font("SansSerif", Font.PLAIN, 50)); // Write String this.text(1 - 0.3, 1 - 0.3, "START!", 20); StdDraw.setPenColor(StdDraw.BLACK); for (int i = 0; i < map.length; i++) { for (int j = 0; j < map[i].length; j++) { if (map[i][j] > 0) { Point2D vLoc = map2Visual(i, j); System.out.println(i + ", " + j + ", " + vLoc); StdDraw.filledCircle(vLoc.getX(), vLoc.getY(), radius); } } } }
// ~ Methods ------------------------------------------------------------ // Retrieve the distance with proper staff border @Override protected double getValue(GlyphContext context) { Glyph stick = context.stick; Point2D stop = stick.getStopPoint(VERTICAL); // Which staff area contains the bottom of the stick? StaffInfo staff = staffManager.getStaffAt(stop); // How far are we from the stop of the staff? double staffBottom = staff.getLastLine().yAt(stop.getX()); double dy = sheet.getScale().pixelsToFrac(Math.abs(staffBottom - stop.getY())); // Change limits according to rough & partDefining if (rough && context.isPartDefining) { setLowHigh(constants.maxStaffShiftDyLowRough, constants.maxStaffShiftDyHighRough); } else { setLowHigh(constants.maxStaffShiftDyLow, constants.maxStaffShiftDyHigh); } // Side-effect if (dy <= getLow()) { context.botStaff = context.bottomArea; } return dy; }
private void draw(Graphics2D g2, Point2D cursor, double width, double height) { double widthFactor = 0.95f; double heightFactor = 0.95f; double yAxeWidth = width - (width * widthFactor); double xAxeHeight = height - height * heightFactor; Point2D.Double localCursor = new Point2D.Double(cursor.getX(), cursor.getY()); localCursor.x += yAxeWidth; plot.draw(g2, localCursor, width * widthFactor, height * heightFactor); Range plotYRange = plot.getPlotModel().getYRange(); AxisState yAxisState = yAxis.build(g2, cursor, yAxeWidth, height * heightFactor, plot.getPlotArea(), plotYRange); localCursor.y += height * heightFactor; Range plotXRange = plot.getPlotModel().getXRange(); AxisState xAxisState = xAxis.build( g2, localCursor, width * widthFactor, xAxeHeight, plot.getPlotArea(), plotXRange); synFontSize(xAxisState, yAxisState); xAxis.draw(); yAxis.draw(); gridRenderer.draw(g2, plot.getPlotArea(), xAxisState, yAxisState); }
/** * Cuando soltamos el botón del ratón desplazamos la imagen a la posición de destino calculando el * extent nuevamente. */ public void mouseReleased(MouseEvent e) throws BehaviorException { if (!isActiveTool()) return; if (e.getButton() == MouseEvent.BUTTON1 && isMoveable) { FLyrRasterSE lyr = grBehavior.getLayer(); if (lyr == null) return; ViewPort vp = grBehavior.getMapControl().getMapContext().getViewPort(); ptoFin = vp.toMapPoint(e.getPoint()); // Asignamos la nueva matriz de transformación a la capa AffineTransform atOld = lyr.getAffineTransform(); AffineTransform atNew = null; double distX = ptoFin.getX() - ptoIni.getX(); double distY = ptoFin.getY() - ptoIni.getY(); // La nueva matriz de transformación es la vieja más la distancia desplazada atNew = new AffineTransform( atOld.getScaleX(), atOld.getShearY(), atOld.getShearX(), atOld.getScaleY(), atOld.getTranslateX() + distX, atOld.getTranslateY() + distY); lyr.setAffineTransform(atNew); grBehavior.getMapControl().getMapContext().invalidate(); isMoveable = false; super.mouseReleased(e); } }
private void updateSubLocations(ZNode node, boolean immediate, Point2D loc) { final Point center = new Point((int) Math.round(loc.getX()), (int) Math.round(loc.getY())); // make bigger when more nodes final float factor = selectedNode == node ? (1.3f + logSize(node.getSubmodules().size()) / 2.2f) : 1.2f; int size = Math.round(sizeMap.get(node) * factor); final float xRatio = display.getWidth() / display.getHeight(); Map<ZNode, Point2D> map = new PixelZNodePositioner( center, new Dimension((int) (size * xRatio), size), new DirectionZNodePositioner(direction, makeNodePositioner())) .getNewPositions(node); for (ZNode sub : node.getSubmodules()) { pointMap.put(sub, map.get(sub)); if (immediate) sub.setLocation((java.awt.geom.Point2D.Float) map.get(sub)); updateSubLocations(sub, immediate, map.get(sub)); } if (node == selectedNode) for (ZNode dep : node.getDependencies()) { pointMap.put(dep, map.get(dep)); if (immediate) dep.setLocation((java.awt.geom.Point2D.Float) map.get(dep)); } }
/** * check if the given position collides with the flashlight. * * @param point * @return */ public boolean flashlightCollision(Point2D point) { flY23 = flY2 - flY3; flX32 = flX3 - flX2; flY31 = flY3 - flY1; flX13 = flX1 - flX3; flDet = flY23 * flX13 - flX32 * flY31; flMinD = Math.min(flDet, 0); flMaxD = Math.max(flDet, 0); double x = point.getX(); double y = point.getY(); double dx = x - flX3; double dy = y - flY3; double a = flY23 * dx + flX32 * dy; if (a < flMinD || a > flMaxD) { return false; } double b = flY31 * dx + flX13 * dy; if (b < flMinD || b > flMaxD) { return false; } double c = flDet - a - b; return !(c < flMinD || c > flMaxD); }
/** * Renders an image on the device * * @param tx the image location on the screen, x coordinate * @param ty the image location on the screen, y coordinate * @param img the image * @param rotation the image rotatation */ private static void renderImage( Graphics2D graphics, double x, double y, Image image, double rotation, float opacity) { AffineTransform temp = graphics.getTransform(); AffineTransform markAT = new AffineTransform(); Point2D mapCentre = new java.awt.geom.Point2D.Double(x, y); Point2D graphicCentre = new java.awt.geom.Point2D.Double(); temp.transform(mapCentre, graphicCentre); markAT.translate(graphicCentre.getX(), graphicCentre.getY()); double shearY = temp.getShearY(); double scaleY = temp.getScaleY(); double originalRotation = Math.atan(shearY / scaleY); markAT.rotate(rotation); graphics.setTransform(markAT); graphics.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, opacity)); // we moved the origin to the centre of the image. graphics.drawImage(image, -image.getWidth(null) / 2, -image.getHeight(null) / 2, null); graphics.setTransform(temp); return; }
public void drawU(UGraphic ug) { ug.apply(new UChangeBackColor(ug.getParam().getColor())).draw(polygon); ug.apply(new UStroke(1.5)) .apply(new UChangeBackColor(HtmlColorUtils.WHITE)) .apply(new UTranslate(dest.getX() - radius, dest.getY() - radius)) .draw(new UEllipse(radius * 2, radius * 2)); }
/** * Method paint. Paints the rings on the graph. * * @param g Graphics - the graphics to be painted. */ @Override public void paint(Graphics g) { Collection<Double> depths = getDepths(); g.setColor(Color.gray); Graphics2D g2d = (Graphics2D) g; Point2D center = radialLayout.getCenter(); Ellipse2D ellipse = new Ellipse2D.Double(); for (double d : depths) { ellipse.setFrameFromDiagonal( center.getX() - d, center.getY() - d, center.getX() + d, center.getY() + d); AffineTransform at = AffineTransform.getTranslateInstance(0, 0); Shape shape = at.createTransformedShape(ellipse); // Shape shape = // vv.getRenderContext().getMultiLayerTransformer().transform(ellipse); // // vv.getRenderContext().getMultiLayerTransformer().getTransformer(Layer.LAYOUT).transform(ellipse); MutableTransformer viewTransformer = vv.getRenderContext().getMultiLayerTransformer().getTransformer(Layer.VIEW); if (viewTransformer instanceof MutableTransformerDecorator) { shape = vv.getRenderContext().getMultiLayerTransformer().transform(shape); } else { shape = vv.getRenderContext().getMultiLayerTransformer().transform(Layer.LAYOUT, shape); } g2d.draw(shape); } }
public void paint(Graphics g) { g.setColor(Color.gray); Graphics2D g2d = (Graphics2D) g; Ellipse2D ellipse = new Ellipse2D.Double(); for (String v : layout.getGraph().getVertices()) { Double radius = layout.getRadii().get(v); if (radius == null) { continue; } Point2D p = layout.transform(v); ellipse.setFrame(-radius, -radius, 2 * radius, 2 * radius); AffineTransform at = AffineTransform.getTranslateInstance(p.getX(), p.getY()); Shape shape = at.createTransformedShape(ellipse); MutableTransformer viewTransformer = vv.getRenderContext().getMultiLayerTransformer().getTransformer(Layer.VIEW); if (viewTransformer instanceof MutableTransformerDecorator) { shape = vv.getRenderContext().getMultiLayerTransformer().transform(shape); } else { shape = vv.getRenderContext().getMultiLayerTransformer().transform(Layer.LAYOUT, shape); } g2d.draw(shape); } }
public Point2D getClosestIntersectionToStart(Shape withThisShape) { // first, get the sides of the shape List<LineSegment> shapeSides = Utilities.getSides(withThisShape); // go through all the sides, and see if there are any intersections // there may be more than 1 List<Point2D> shapeIntersectionPoints = new ArrayList<Point2D>(); for (Line2D curSide : shapeSides) { if (curSide.intersectsLine(this)) { Point2D intersectionPoint = Utilities.getIntersectionPoint(this, curSide); shapeIntersectionPoints.add(intersectionPoint); } } if (shapeIntersectionPoints.size() <= 0) { return null; } else if (shapeIntersectionPoints.size() == 1) { return shapeIntersectionPoints.get(0); } else { // get the point closest to P1 Point2D closestIntersectionPoint = null; double closestIntersectionPointDistSq = java.lang.Double.MAX_VALUE; for (Point2D curPoint : shapeIntersectionPoints) { double curDistSq = curPoint.distanceSq(this.getP1()); if (curDistSq < closestIntersectionPointDistSq) { closestIntersectionPointDistSq = curDistSq; closestIntersectionPoint = curPoint; } } return closestIntersectionPoint; } }
final double getMindist(Point2D.Double pt) { double result = Double.MAX_VALUE; for (Point2D p : points.keySet()) { if (pt.equals(p)) { continue; } final double v = p.distance(pt); if (v < 1E-4) { throw new IllegalStateException(); } result = Math.min(result, v); } for (Line2D line : lines) { if (line.getP1().equals(pt) || line.getP2().equals(pt)) { continue; } final double v = line.ptSegDist(pt); if (result < 1E-4) { throw new IllegalStateException("pt=" + pt + " line=" + GeomUtils.toString(line)); } result = Math.min(result, v); } if (result == 0) { throw new IllegalStateException(); } // Log.println("getMindist=" + result); return result; }
/** * Draws an item label. * * @param g2 the graphics device. * @param orientation the orientation. * @param dataset the dataset. * @param series the series index (zero-based). * @param item the item index (zero-based). * @param x the x coordinate (in Java2D space). * @param y the y coordinate (in Java2D space). * @param negative indicates a negative value (which affects the item label position). */ private void drawAdditionalItemLabel( Graphics2D g2, PlotOrientation orientation, XYDataset dataset, int series, int item, double x, double y) { if (this.additionalItemLabelGenerator == null) { return; } Font labelFont = getItemLabelFont(series, item); Paint paint = getItemLabelPaint(series, item); g2.setFont(labelFont); g2.setPaint(paint); String label = this.additionalItemLabelGenerator.generateLabel(dataset, series, item); ItemLabelPosition position = getNegativeItemLabelPosition(series, item); Point2D anchorPoint = calculateLabelAnchorPoint(position.getItemLabelAnchor(), x, y, orientation); TextUtilities.drawRotatedString( label, g2, (float) anchorPoint.getX(), (float) anchorPoint.getY(), position.getTextAnchor(), position.getAngle(), position.getRotationAnchor()); }
/** make new shape polygon */ private void reMakePolygonShape() { ConvexHull convexHull; List<Point> newPoints = new ArrayList<Point>(); for (int j = 0; j < polygon.npoints; j++) { if (mainClusterShape.contains(polygon.xpoints[j], polygon.ypoints[j])) { newPoints.add(new Point(polygon.xpoints[j], polygon.ypoints[j])); } } for (Point2D point2D : getIntersectPoint()) { newPoints.add(new Point((int) point2D.getX(), (int) point2D.getY())); } for (int i = 0; i < mainClusterShape.npoints; i++) { if (polygon.contains(mainClusterShape.xpoints[i], mainClusterShape.ypoints[i])) { Point point = new Point(mainClusterShape.xpoints[i], mainClusterShape.ypoints[i]); newPoints.add(point); } } convexHull = new ConvexHull(); for (Point point : newPoints) { convexHull.addPoint((int) point.getX(), (int) point.getY()); } setPolygon(convexHull.convex()); newPoints.clear(); }
/** * Return the raster coordinate denoted by the given world coordinate. This method is CENTER and * OUTER aware. * * @param worldX x position in the world coordinate system, for which raster coordinates should be * calculated. * @param worldY y position in the world coordinate system, for which raster coordinates should be * calculated. * @return the (rounded) raster coordinate which the given world coordinate maps to. */ public int[] getRasterCoordinate(double worldX, double worldY) { Point2D rslt = invTransform.transform(new Point2D.Double(worldX, worldY), null); if (location == CENTER) { return new int[] {(int) round(rslt.getX()), (int) round(rslt.getY())}; } return new int[] {(int) floor(rslt.getX()), (int) floor(rslt.getY())}; }
private static Point2D vectorToLocation( double angle, double length, Point2D sourceLocation, Point2D targetLocation) { targetLocation.setLocation( sourceLocation.getX() + Math.sin(angle) * length, sourceLocation.getY() + Math.cos(angle) * length); return targetLocation; }
/** * creates a svg element by specifiying its parameters * * @param handle the current svg handle * @param text the text for the new element * @return the created svg element */ public Element createElement(SVGHandle handle, String text) { // the edited document Document doc = handle.getScrollPane().getSVGCanvas().getDocument(); // creating the text element final Element element = doc.createElementNS(doc.getDocumentElement().getNamespaceURI(), handledElementTagName); // getting the last color that has been used by the user String colorString = Editor.getColorChooser().getColorString(ColorManager.getCurrentColor()); element.setAttributeNS(null, "style", "fill:" + colorString + ";stroke:none;"); element.setAttributeNS(null, "style", "font-size:12pt;fill:" + colorString + ";"); EditorToolkit.setAttributeValue(element, xAtt, drawingPoint.getX()); EditorToolkit.setAttributeValue(element, yAtt, drawingPoint.getY()); // creating the text node Text textValue = doc.createTextNode(text); element.appendChild(textValue); // inserting the element in the document and handling the undo/redo // support insertShapeElement(handle, element); handle.getSelection().handleSelection(element, false, false); return element; }
/** * Hook for subclassers to paint the background page(s). * * @param g2 The graphics object to paint the background page(s) on. */ protected void paintBackgroundPages(Graphics2D g2) { Point2D p = graph.toScreen(new Point2D.Double(pageFormat.getWidth(), pageFormat.getHeight())); Dimension pSize = graph.getPreferredSize(); int w = (int) (p.getX() * pageScale); int h = (int) (p.getY() * pageScale); int cols = (int) Math.max(Math.ceil((double) (pSize.width - 5) / (double) w), 1); int rows = (int) Math.max(Math.ceil((double) (pSize.height - 5) / (double) h), 1); g2.setColor(graph.getHandleColor()); // Draws the pages. Point offset = getViewPosition(); g2.translate(-offset.x, -offset.y); g2.fillRect(0, 0, graph.getWidth(), graph.getHeight()); g2.setColor(Color.darkGray); g2.fillRect(3, 3, cols * w, rows * h); g2.setColor(getGraph().getBackground()); g2.fillRect(1, 1, cols * w - 1, rows * h - 1); // Draws the pagebreaks. Stroke previousStroke = g2.getStroke(); g2.setStroke( new BasicStroke( 1, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 10.0f, new float[] {1, 2}, 0)); g2.setColor(Color.darkGray); for (int i = 1; i < cols; i++) g2.drawLine(i * w, 1, i * w, rows * h - 1); for (int i = 1; i < rows; i++) g2.drawLine(1, i * h, cols * w - 1, i * h); // Restores the graphics. g2.setStroke(previousStroke); g2.translate(offset.x, offset.y); g2.clipRect(0, 0, cols * w - 1 - offset.x, rows * h - 1 - offset.y); }
/** Redraws the image. */ private void redrawImage() { ScreenToWorldPointConverter converter = null; try { converter = new ScreenToWorldPointConverter( currWXMin, currWYMin, currWXMax, currWYMax, 0, 0, width - 1, height - 1); } catch (Exception e) { throw new IllegalStateException(e); } Point2D P = null; Point2D.Double screenPoint = new Point2D.Double(); ComplexNumber C = null; Color theColor = null; int colorIndex = 0; for (int i = 0; i < width; ++i) { for (int j = 0; j < height; ++j) { screenPoint.setLocation(i, j); P = converter.getWorldCoordinates(screenPoint); C = new ComplexNumber(new RealNumber(P.getX()), new RealNumber(P.getY())); colorIndex = Mandelbrot.divergenceIndex(C); if (colorIndex < 0) { theColor = Color.black; } else { theColor = Mandelbrot.getColor(colorIndex); } img.paintPixel(i, j, theColor.getRGB()); } } }
public static void main(String[] args) { Scanner scanRadius = new Scanner(System.in); Scanner scanCenter = new Scanner(System.in); Point2D centerA = new Point2D.Double(); Point2D centerB = new Point2D.Double(); double x, y, radiusA = 0, radiusB = 0; for (char i = 'A'; i <= 'B'; i++) { System.out.print("\nCircle " + i); System.out.print("\nEnter center cordinates:" + "\n(x): "); x = scanCenter.nextDouble(); System.out.print("(y): "); y = scanCenter.nextDouble(); System.out.print("Enter radius: "); if (i == 'A') { radiusA = scanCenter.nextDouble(); centerA.setLocation(x, y); } else if (i == 'B') { radiusB = scanCenter.nextDouble(); centerB.setLocation(x, y); } } scanRadius.close(); scanCenter.close(); double distance = distance(centerA, centerB); if (distance == (radiusA + radiusB)) System.out.println("\nThe two circles are touching"); else if ((distance < Math.abs(radiusA - radiusB))) System.out.println("\nOne circle encloses another"); else if (distance < (radiusA + radiusB)) System.out.println("\nThe two circles overlap"); else if (distance > (radiusA + radiusB)) System.out.println("\nThe two circles are separate"); }
private Point2D getImageOffset(ImageListViewCell cell) { Point2D imgSize = getScaledImageSize(cell); Dimension latestSize = cell.getLatestSize(); return new Point2D.Double( (latestSize.width + 2 * cell.getCenterOffset().getX() - (int) imgSize.getX()) / 2, (latestSize.height + 2 * cell.getCenterOffset().getY() - (int) imgSize.getY()) / 2); }
@Override protected void paintComponent(Graphics g) { super.paintComponent(g); Graphics2D g2 = (Graphics2D) g; if (moveThread != null) { if (moveThread.isRunning()) { Point2D p = moveThread.getCurrentPosition(); currentDirection = moveThread.getDirection(); this.setBounds((int) p.getX() - 32, (int) p.getY() - 32, 96, 64); } else { if (currentDirection == HeroDirection.MOVING_BACK) { currentDirection = HeroDirection.IDLE_BACK; } else if (currentDirection == HeroDirection.MOVING_FRONT) { currentDirection = HeroDirection.IDLE_FRONT; } else if (currentDirection == HeroDirection.MOVING_LEFT) { currentDirection = HeroDirection.IDLE_LEFT; } else if (currentDirection == HeroDirection.MOVING_RIGHT) { currentDirection = HeroDirection.IDLE_RIGHT; } moveThread = null; isMoveFinished = true; } } g2.drawImage(animation.getCurrentFrame(currentDirection), 0, 0, null); }
private void doShooting() { PositionFinder p = new PositionFinder(enemies, this); en = p.findNearest(); if (en == null) return; Point2D myPos = new Point2D.Double(getX(), getY()); if (HoT) { /* Perform head on target for gun movement */ aimingPoint = new Point2D.Double(en.getX(), en.getY()); double turnGunAmt = (getHeadingRadians() + en.getBearingRadians() - getGunHeadingRadians()); turnGunAmt = Utils.normalRelativeAngle(turnGunAmt); setTurnGunRightRadians(turnGunAmt); } else { /* Perform circular targeting */ Rectangle2D battlefield = new Rectangle2D.Double(0, 0, getBattleFieldWidth(), getBattleFieldHeight()); long when = calcTimeToReachEnemy(); aimingPoint = org.pattern.utils.Utils.getFuturePoint(en, when); if (!battlefield.contains(aimingPoint)) { HoT = true; return; } double theta = Utils.normalAbsoluteAngle( Math.atan2(aimingPoint.getX() - getX(), aimingPoint.getY() - getY())); setTurnGunRightRadians(Utils.normalRelativeAngle(theta - getGunHeadingRadians())); } if (getGunHeat() == 0) { double firePower = 3.0; fire(firePower); } }