/** loads the sprites to be used for the bots */
  public static void loadSprites() {

    try {

      mainImageEast = ImageIO.read(new File("char/archer_east.png"));
      mainImageWest = ImageIO.read(new File("char/archer_west.png"));

      north = new BufferedImage[frameCount];
      south = new BufferedImage[frameCount];
      east = new BufferedImage[frameCount];
      west = new BufferedImage[frameCount];
      north_east = new BufferedImage[frameCount];
      north_west = new BufferedImage[frameCount];
      south_east = new BufferedImage[frameCount];
      south_west = new BufferedImage[frameCount];

      for (int i = 0; i < frameCount; i++) {
        north[i] = mainImageEast.getSubimage(0 * width, height * i, width, height);
        north_east[i] = mainImageEast.getSubimage(1 * width, height * i, width, height);
        east[i] = mainImageEast.getSubimage(2 * width, height * i, width, height);
        south_east[i] = mainImageEast.getSubimage(3 * width, height * i, width, height);
        south[i] = mainImageEast.getSubimage(4 * width, height * i, width, height);

        north_west[i] = mainImageWest.getSubimage(3 * width, height * i, width, height);
        west[i] = mainImageWest.getSubimage(2 * width, height * i, width, height);
        south_west[i] = mainImageWest.getSubimage(1 * width, height * i, width, height);
      }

    } catch (Exception e) {
      System.out.println("Spritesheet Not Found!");
    }
  }
Ejemplo n.º 2
0
  private void drawSelection(Graphics2D g2d) {
    if (srcx != destx || srcy != desty) {
      int x1 = (srcx < destx) ? srcx : destx;
      int y1 = (srcy < desty) ? srcy : desty;
      int x2 = (srcx > destx) ? srcx : destx;
      int y2 = (srcy > desty) ? srcy : desty;

      rectSelection.x = x1;
      rectSelection.y = y1;
      rectSelection.width = (x2 - x1) + 1;
      rectSelection.height = (y2 - y1) + 1;
      if (rectSelection.width > 0 && rectSelection.height > 0) {
        g2d.drawImage(scr_img.getSubimage(x1, y1, x2 - x1 + 1, y2 - y1 + 1), null, x1, y1);
      }

      g2d.setColor(selFrameColor);
      g2d.setStroke(bs);
      g2d.draw(rectSelection);
      int cx = (x1 + x2) / 2;
      int cy = (y1 + y2) / 2;
      g2d.setColor(selCrossColor);
      g2d.setStroke(_StrokeCross);
      g2d.drawLine(cx, y1, cx, y2);
      g2d.drawLine(x1, cy, x2, cy);

      if (Screen.getNumberScreens() > 1) {
        drawScreenFrame(g2d, srcScreenId);
      }
    }
  }
Ejemplo n.º 3
0
  public void generarFondo(Component componente) {
    boolean dibujarFondo = false;
    Rectangle med = this.getBounds();
    Rectangle areaDibujo = this.getBounds();
    BufferedImage tmp;
    GraphicsConfiguration gc =
        GraphicsEnvironment.getLocalGraphicsEnvironment()
            .getDefaultScreenDevice()
            .getDefaultConfiguration();

    if (Principal.fondoBlur) {
      dibujarFondo = true;
    }
    if (dibujarFondo) {
      JRootPane root = SwingUtilities.getRootPane(this);
      blurBuffer = GraphicsUtilities.createCompatibleImage(Principal.sysAncho, Principal.sysAlto);
      Graphics2D g2 = blurBuffer.createGraphics();
      g2.setClip(med);
      blurBuffer = blurBuffer.getSubimage(med.x, med.y, med.width, med.height);
      ((Escritorio) Principal.getEscritorio()).getFrameEscritorio().paint(g2);
      g2.dispose();
      backBuffer = blurBuffer;
      // blurBuffer = toGrayScale(blurBuffer);
      blurBuffer = GraphicsUtilities.createThumbnailFast(blurBuffer, getWidth() / 2);
      blurBuffer = new GaussianBlurFilter(4).filter(blurBuffer, null);
      g2 = (Graphics2D) blurBuffer.getGraphics();
      g2.setColor(new Color(0, 0, 0, 195));
      g2.fillRect(0, 0, Principal.sysAncho, Principal.sysAlto);
      listo = true;
    }
  }
Ejemplo n.º 4
0
  public void loadTiles(String s) {

    try {

      tileset = ImageIO.read(new File(s));
      int numTilesAcross = (tileset.getWidth() + 1) / (tileSize + 1);
      tiles = new Tile[2][numTilesAcross];

      BufferedImage subimage;
      for (int col = 0; col < numTilesAcross; col++) {
        subimage = tileset.getSubimage(col * tileSize + col, 0, tileSize, tileSize);
        tiles[0][col] = new Tile(subimage, false);
        subimage = tileset.getSubimage(col * tileSize + col, tileSize + 1, tileSize, tileSize);
        tiles[1][col] = new Tile(subimage, true);
      }

    } catch (Exception e) {
      e.printStackTrace();
    }
  }
Ejemplo n.º 5
0
 // compare the two images in this object.
 public void compare() {
   // setup change display image
   imgc = imageToBufferedImage(img1);
   Graphics2D gc = imgc.createGraphics();
   gc.setColor(Color.RED);
   // convert to gray images.
   img1 = imageToBufferedImage(GrayFilter.createDisabledImage(img1));
   img2 = imageToBufferedImage(GrayFilter.createDisabledImage(img2));
   // how big are each section
   int blocksx = (int) (img1.getWidth() / comparex);
   int blocksy = (int) (img1.getHeight() / comparey);
   // set to a match by default, if a change is found then flag non-match
   this.match = true;
   // loop through whole image and compare individual blocks of images
   for (int y = 0; y < comparey; y++) {
     if (debugMode > 0) System.out.print("|");
     for (int x = 0; x < comparex; x++) {
       int b1 =
           getAverageBrightness(
               img1.getSubimage(x * blocksx, y * blocksy, blocksx - 1, blocksy - 1));
       int b2 =
           getAverageBrightness(
               img2.getSubimage(x * blocksx, y * blocksy, blocksx - 1, blocksy - 1));
       int diff = Math.abs(b1 - b2);
       if (diff
           > factorA) { // the difference in a certain region has passed the threshold value of
                        // factorA
         // draw an indicator on the change image to show where change was detected.
         gc.drawRect(x * blocksx, y * blocksy, blocksx - 1, blocksy - 1);
         this.match = false;
       }
       if (debugMode == 1) System.out.print((diff > factorA ? "X" : " "));
       if (debugMode == 2) System.out.print(diff + (x < comparex - 1 ? "," : ""));
     }
     if (debugMode > 0) System.out.println("|");
   }
 }
Ejemplo n.º 6
0
 private BufferedImage cropSelection() {
   int w = rectSelection.width, h = rectSelection.height;
   if (w <= 0 || h <= 0) {
     return null;
   }
   BufferedImage crop = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
   Graphics2D crop_g2d = crop.createGraphics();
   try {
     crop_g2d.drawImage(scr_img.getSubimage(rectSelection.x, rectSelection.y, w, h), null, 0, 0);
   } catch (RasterFormatException e) {
     Debug.error(e.getMessage());
   }
   crop_g2d.dispose();
   return crop;
 }
Ejemplo n.º 7
0
  public ImageFont(String pathToImage, int numCols, int numRows) {
    try {
      tilesImg = convertToARGB(ImageIO.read(new File(pathToImage)));

      this.imgW = tilesImg.getWidth();
      this.imgH = tilesImg.getHeight();
      this.numCols = numCols;
      this.numRows = numRows;
      this.numTiles = numCols * numRows;
      this.tW = this.imgW / this.numCols;
      this.tH = this.imgH / this.numRows;

      this.tiles = new BufferedImage[this.numTiles];

      for (int i = 0; i < numCols; i++) {
        for (int j = 0; j < numRows; j++) {
          tiles[(numCols * j) + i] = tilesImg.getSubimage(i * tW, j * tH, tW, tH);
        }
      }
    } catch (IOException e) {
      System.out.println("Couldn't load the image: " + e);
    }
  }
  public void insertBuilding(int i, int j, int index) {

    if (!tiles[i][j].getValue().equals("")) {
      JOptionPane.showMessageDialog(null, "There is already a building here");
      return;
    }

    String temp = bb.get(index).getText();
    String[] parts = temp.split("-");

    int newQ = Integer.parseInt(parts[1]) - 1;
    if (newQ < 0) return;

    Building tB = bList.get(0);
    for (int b = 0; b < bList.size(); b++) {
      if (bList.get(b).getName().equals(parts[0])) {
        tB = bList.get(b);
        // System.out.println("here");
        break;
      }
    }

    Image image = null;
    BufferedImage buffered;
    try {
      image = ImageIO.read(new File("images/" + tB.getName().replace(" ", "_") + ".png"));
      System.out.println("Loaded image");
    } catch (IOException e) {
      System.out.println("Failed to load image");
    }
    buffered = (BufferedImage) image;

    for (int c = 0; c < tB.getQWidth(); c++) {
      for (int r = 0; r < tB.getQHeight(); r++) {
        if (i + c == 40 || j + r == 40) {
          JOptionPane.showMessageDialog(null, "Placing a building here would be out of bounds");
          return;
        }

        if (!tiles[i + c][j + r].getValue().equals("")) {
          JOptionPane.showMessageDialog(null, "Placing a building here will result to a overlap");
          return;
        }
      }
    }

    double w = buffered.getWidth() / tB.getQWidth();
    double h = buffered.getHeight() / tB.getQHeight();

    for (int c = 0; c < tB.getQWidth(); c++) {
      for (int r = 0; r < tB.getQHeight(); r++) {
        tiles[i + c][j + r].setBackground(new Color(51, 204, 51));
        tiles[i + c][j + r].setIcon(
            new ImageIcon(
                resize(
                    buffered.getSubimage((int) w * r, (int) h * c, (int) w, (int) h),
                    tiles[i + c][j + r].getWidth(),
                    tiles[i + c][j + r].getHeight())));

        String tValue = (c == 0 && r == 0) ? tB.getName() : i + "-" + j;
        // System.out.println(tValue);
        tiles[i + c][j + r].setValue(tValue);
      }
    }

    // tiles[i][j].setBackground(Color.BLUE);
    bb.get(index).setText(parts[0] + "-" + newQ);
  }
Ejemplo n.º 9
0
  private BufferedImage getSpecificImage(
      int x,
      int y,
      int w,
      int h,
      int imgIndexX,
      int imgIndexY,
      BufferedImage buffImg,
      int zoom,
      int cachedZoom,
      GMapListener listener,
      boolean localFilesOnly) {

    int xIndex = x / GDataSource.sourceSize.width;
    int yIndex = y / GDataSource.sourceSize.height;

    xIndex += imgIndexX;
    yIndex += imgIndexY;

    BufferedImage image = null;
    if (!localFilesOnly || getGDataSource().isCached(xIndex, yIndex, zoom))
      image = getIndexedImage(xIndex, yIndex, zoom, cachedZoom, listener);

    int xCoord = x % GDataSource.sourceSize.width;
    int yCoord = y % GDataSource.sourceSize.height;

    // Checks for invalid xCoord and yCoord
    if (xCoord < 0) {
      xCoord = 0;
    }
    if (yCoord < 0) {
      yCoord = 0;
    }

    // get info about the image
    Dimension imageSize =
        new Dimension(getGDataSource().sourceSize.width, getGDataSource().sourceSize.height);

    // find the width of what we CAN paint
    int initPaintWidth = imageSize.width - xCoord;
    int initPaintHeight = imageSize.height - yCoord;

    int paintWidth = initPaintWidth;
    int paintHeight = initPaintHeight;

    int rowImages = numOfRows(x, y, h, zoom, cachedZoom);
    int colImages = numOfCols(x, y, w, zoom, cachedZoom);

    if (imgIndexX >= colImages || imgIndexY >= rowImages) {
      return null;
    }

    int xImage = 0;
    int yImage = 0;

    int xInitCoord = xCoord;
    int yInitCoord = yCoord;

    if (imgIndexX > 0) {
      xImage = initPaintWidth + (imgIndexX - 1) * imageSize.width;
      xCoord = 0;
      if (imgIndexX < (colImages - 1)) {
        paintWidth = imageSize.width;
      } else {
        paintWidth = w - ((colImages - 2) * imageSize.width) - (imageSize.width - xInitCoord);
      }
    }
    if (imgIndexY > 0) {
      yImage = initPaintHeight + (imgIndexY - 1) * imageSize.height;
      yCoord = 0;
      if (imgIndexY < (rowImages - 1)) {
        paintHeight = imageSize.height;
      } else {
        paintHeight = h - ((rowImages - 2) * imageSize.height) - (imageSize.height - yInitCoord);
      }
    }

    if (buffImg != null) {
      Graphics2D g = (Graphics2D) buffImg.getGraphics();
      if (image != null) {
        // System.out.println(xCoord + ":" + yCoord + ":" + paintWidth + ":" + paintHeight);
        g.drawImage(
            image.getSubimage(xCoord, yCoord, paintWidth, paintHeight),
            xImage,
            yImage,
            paintWidth,
            paintHeight,
            null);
      } else {
        Composite originalComposite = g.getComposite();
        g.setComposite(opacity40);
        g.setColor(Color.BLACK);
        g.fillRect(xImage, yImage, paintWidth, paintHeight);
        g.setComposite(originalComposite);
      }
    }

    return buffImg;
  }
Ejemplo n.º 10
0
  protected void paintToImage(Component c, Graphics gr, int width, int height, Object args) {
    // Cast Graphics to Graphics2D
    // Workaround for Java 1.4 and 1.4 on Mac OS X 10.4. We create a new
    // Graphics object instead of just casting the provided one. This is
    // because drawing texture paints appears to confuse the Graphics object.
    Graphics2D g = (Graphics2D) gr.create();

    // Convert image to buffered image (and keep the buffered image).
    image = Images.toBufferedImage(image);
    BufferedImage img = (BufferedImage) image;

    // Set some variables for easy access of insets and image size
    int top = imageInsets.top;
    int left = imageInsets.left;
    int bottom = imageInsets.bottom;
    int right = imageInsets.right;
    int imgWidth = img.getWidth();
    int imgHeight = img.getHeight();

    // Optimisation: Draw image directly if it fits into the component
    if (fillContentArea) {
      if (width == imgWidth && height == imgHeight) {
        g.drawImage(img, 0, 0, c);
        g.dispose();
        return;
      }
    }

    // Optimisation: Remove insets, if image width or image height fits
    if (width == imgWidth) {
      left = imgWidth;
      right = 0;
    }
    if (height == imgHeight) {
      top = imgHeight;
      bottom = 0;
    }

    // Adjust insets if component is too small
    if (width < left + right) {
      left = Math.min(left, width / 2); // Math.max(0, left + (width - left - right) / 2);
      right = width - left;
    }
    if (height < top + bottom) {
      top = Math.min(top, height / 2); // Math.max(0, top + (height - top - bottom) / 2);
      bottom = height - top;
    }

    // Draw the Corners
    if (top > 0 && left > 0) {
      g.drawImage(img, 0, 0, left, top, 0, 0, left, top, c);
    }
    if (top > 0 && right > 0) {
      // g.fillRect(x+width-right, y, x+width, y+top);
      g.drawImage(img, width - right, 0, width, top, imgWidth - right, 0, imgWidth, top, c);
    }
    if (bottom > 0 && left > 0) {
      g.drawImage(img, 0, height - bottom, left, height, 0, imgHeight - bottom, left, imgHeight, c);
    }
    if (bottom > 0 && right > 0) {
      g.drawImage(
          img,
          width - right,
          height - bottom,
          width,
          height,
          imgWidth - right,
          imgHeight - bottom,
          imgWidth,
          imgHeight,
          c);
    }

    // Draw the edges
    BufferedImage subImg = null;
    TexturePaint paint;

    // North
    if (top > 0 && left + right < width) {
      if (imgWidth > right + left) {
        subImg = img.getSubimage(left, 0, imgWidth - right - left, top);
        paint = new TexturePaint(subImg, new Rectangle(left, 0, imgWidth - left - right, top));
        g.setPaint(paint);
        g.fillRect(left, 0, width - left - right, top);
      }
    }
    // South
    if (bottom > 0 && left + right < width) {
      if (imgHeight > bottom && imgWidth > right + left) {
        subImg = img.getSubimage(left, imgHeight - bottom, imgWidth - right - left, bottom);
        paint =
            new TexturePaint(
                subImg, new Rectangle(left, height - bottom, imgWidth - left - right, bottom));
        g.setPaint(paint);
        g.fillRect(left, height - bottom, width - left - right, bottom);
      }
    }
    // West
    if (left > 0 && top + bottom < height) {
      if (imgHeight > top + bottom) {
        subImg = img.getSubimage(0, top, left, imgHeight - top - bottom);
        paint = new TexturePaint(subImg, new Rectangle(0, top, left, imgHeight - top - bottom));
        g.setPaint(paint);
        g.fillRect(0, top, left, height - top - bottom);
      }
    }
    // East
    if (right > 0 && top + bottom < height) {
      if (imgWidth > right && imgHeight > top + bottom) {
        subImg = img.getSubimage(imgWidth - right, top, right, imgHeight - top - bottom);
        paint =
            new TexturePaint(
                subImg, new Rectangle(width - right, top, right, imgHeight - top - bottom));
        g.setPaint(paint);
        g.fillRect(width - right, top, right, height - top - bottom);
      }
    }

    // Fill the center
    if (fillContentArea) {
      if (left + right < imgWidth && top + bottom < imgHeight) {
        subImg = img.getSubimage(left, top, imgWidth - right - left, imgHeight - top - bottom);
        paint =
            new TexturePaint(
                subImg,
                new Rectangle(left, top, imgWidth - right - left, imgHeight - top - bottom));
        g.setPaint(paint);
        g.fillRect(left, top, width - right - left, height - top - bottom);
      }
    }
    g.dispose();
  }