Ejemplo n.º 1
0
 protected void setActive(Component component, boolean active) {
   if (component instanceof Tile) {
     Tile tile = (Tile) component;
     if (active) {
       tile.addTiledView(_points);
       tile.addMouseListener(_ml);
       tile.addMouseWheelListener(_mwl);
       InputMap im = tile.getInputMap();
       ActionMap am = tile.getActionMap();
       im.put(KS_BACK_SPACE, "backspace");
       im.put(KS_UP, "up");
       im.put(KS_DOWN, "down");
       am.put("backspace", _bsa);
       am.put("up", _uaa);
       am.put("down", _daa);
     } else {
       tile.removeTiledView(_points);
       tile.removeMouseListener(_ml);
       tile.removeMouseWheelListener(_mwl);
       InputMap im = tile.getInputMap();
       ActionMap am = tile.getActionMap();
       im.remove(KS_BACK_SPACE);
       im.remove(KS_UP);
       im.remove(KS_DOWN);
       am.remove("backspace");
       am.remove("up");
       am.remove("down");
     }
   }
 }
Ejemplo n.º 2
0
  /**
   * Loads the tileset defined in the constructor into a JPanel which it then returns. Makes no
   * assumptions about height or width, which means it needs to read an extra 64 tiles at worst (32
   * down to check height and 32 across for width), since the maximum height/width is 32 tiles.
   */
  public JPanel loadTileset() {
    int height = MAX_TILESET_SIZE;
    int width = MAX_TILESET_SIZE;

    boolean maxHeight = false;
    boolean maxWidth = false;

    // find width
    int j = 0;
    while (!maxWidth) {
      try {
        File f = new File(tileDir + "/" + j + "_" + 0 + ".png");
        ImageIO.read(f);
      } catch (IOException e) {
        width = j;
        maxWidth = true;
      }
      j += TILE_SIZE;
    }

    // find height
    int i = 0;
    while (!maxHeight) {
      try {
        File f = new File(tileDir + "/" + 0 + "_" + i + ".png");
        ImageIO.read(f);
      } catch (IOException e) {
        height = i;
        maxHeight = true;
      }
      i += TILE_SIZE;
    }

    JPanel tileDisplay = new JPanel();
    tileDisplay.setLayout(new GridLayout(height / TILE_SIZE, width / TILE_SIZE));
    tileDisplay.setMinimumSize(new Dimension(width, height));
    tileDisplay.setPreferredSize(new Dimension(width, height));
    tileDisplay.setMaximumSize(new Dimension(width, height));

    for (i = 0; i < height; i += TILE_SIZE) {
      for (j = 0; j < width; j += TILE_SIZE) {
        String fPath = tileDir + "/" + j + "_" + i;
        try {
          int[] mov = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};

          Image icon = getTile(tileDir, j, i, 1);
          Tile tile =
              new Tile(new ImageIcon(icon), "palette", 0, 0, mov, "none", false, "" + j + "_" + i);
          tile.addMouseListener(new PaletteButtonListener());
          tile.setMaximumSize(new Dimension(TILE_SIZE, TILE_SIZE));
          tile.setPreferredSize(new Dimension(TILE_SIZE, TILE_SIZE));
          tile.setMinimumSize(new Dimension(TILE_SIZE, TILE_SIZE));
          tileDisplay.add(tile);
        } catch (IOException e) {
        }
      }
    }
    return tileDisplay;
  }
Ejemplo n.º 3
0
  public Map loadMap(File input) throws FileNotFoundException {
    Scanner s = new Scanner(input);
    tileDir = s.nextLine();
    int width = s.nextInt();
    int height = s.nextInt();
    Map toReturn = new Map(width, height, tileDir);
    s.nextLine(); // eat up rest of line.
    for (int y = 0; y < height; y++) {
      String line = s.nextLine();
      Scanner lineReader = new Scanner(line);
      List<Tile> tList = new ArrayList<Tile>();
      for (int x = 0; x < width; x++) {
        String[] values = lineReader.next().split("/");
        String name = values[0];
        int[] picLocation = new int[2];
        for (int i = 0; i < picLocation.length; i++) {
          picLocation[i] = Integer.parseInt(values[1].split("_")[i]);
        }
        ImageIcon img = null;
        try {
          img = new ImageIcon(getTile(tileDir, picLocation[0], picLocation[1], DISPLAY_SCALE));
        } catch (IOException e) {
          System.out.println("Could not find image.");
          img =
              new ImageIcon(
                  new BufferedImage(
                      TILE_SIZE * DISPLAY_SCALE,
                      TILE_SIZE * DISPLAY_SCALE,
                      BufferedImage.TYPE_INT_RGB));
        }
        int avoid = Integer.parseInt(values[2]);
        int def = Integer.parseInt(values[3]);
        String[] movString = values[4].split(",");
        int[] moveCost = new int[movString.length];
        for (int i = 0; i < moveCost.length; i++) {
          moveCost[i] = Integer.parseInt(movString[i]);
        }
        String special = values[5];

        Tile t =
            new Tile(
                img,
                name,
                avoid,
                def,
                moveCost,
                special,
                true,
                "" + picLocation[0] + "_" + picLocation[1]);
        tList.add(t);
        t.setMaximumSize(new Dimension(TILE_SIZE * DISPLAY_SCALE, TILE_SIZE * DISPLAY_SCALE));
        t.setPreferredSize(new Dimension(TILE_SIZE * DISPLAY_SCALE, TILE_SIZE * DISPLAY_SCALE));
        t.addMouseListener(new MapButtonListener());
      }
      toReturn.addRow(tList);
    }
    return toReturn;
  }
Ejemplo n.º 4
0
 /**
  * Returns a map with the specified dimensions filled with the currTile image. The image should be
  * the upper-left tile of a given tileset if this is called from the constructor.
  */
 public Map emptyMap(int width, int height) {
   Map toReturn = new Map(width, height, tileDir);
   int[] mov = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
   for (int i = 0; i < height; i++) {
     List<Tile> tList = new ArrayList<Tile>();
     for (int j = 0; j < width; j++) {
       Tile t = new Tile(currTileImg, "Test", 0, 0, mov, "none", true, currTileLoc);
       tList.add(t);
       // t.setMargin(new Insets(0,0,0,0));
       t.setMaximumSize(new Dimension(TILE_SIZE * DISPLAY_SCALE, TILE_SIZE * DISPLAY_SCALE));
       t.setPreferredSize(new Dimension(TILE_SIZE * DISPLAY_SCALE, TILE_SIZE * DISPLAY_SCALE));
       // tile.setPreferredSize(new Dimension(TILE_SIZE*DISPLAY_SCALE, TILE_SIZE*DISPLAY_SCALE));
       t.addMouseListener(new MapButtonListener());
     }
     toReturn.addRow(tList);
   }
   return toReturn;
 }
Ejemplo n.º 5
0
    public void actionPerformed(ActionEvent e) {
      int tempW = mapWidth;
      int tempH = mapHeight;
      int targetW;
      int targetH;
      try {
        targetW = Integer.parseInt(widthField.getText());
        targetH = Integer.parseInt(heightField.getText());

        if (targetH <= 0 || targetW <= 0) {
          JOptionPane.showMessageDialog(null, "Both x and y must be above 0.");
        } else {

          // shrink width if necessary
          while (targetW < mapWidth) {
            for (int i = mapHeight * mapWidth - 1; i >= 0; i -= mapWidth) {
              map.remove(i);
            }
            mapWidth--;
            mapScroll.revalidate();
            map.repaint();

            backEnd.removeColumn(backEnd.getWidth() - 1);
          }

          // shrink height if necessary
          while (targetH < mapHeight) {
            for (int i = 1; i <= mapWidth; i++) {
              map.remove(mapHeight * mapWidth - i);
            }
            mapHeight--;
            // map.setLayout(new GridLayout(mapHeight,mapWidth));
            map.repaint();
            backEnd.removeRow(backEnd.getHeight() - 1);
          }

          // Grow if necessary
          if (targetW > mapWidth || targetH > mapHeight) {
            // add new rows and columns, then rebuild and re-add display
            int[] mov = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
            while (targetW > mapWidth) {
              // add new column to backEnd
              List<Tile> tList = new ArrayList<Tile>();
              for (int i = 0; i < mapHeight; i++) {
                Tile t = new Tile(currTileImg, "Test", 0, 0, mov, "none", true, currTileLoc);
                t.setPreferredSize(
                    new Dimension(TILE_SIZE * DISPLAY_SCALE, TILE_SIZE * DISPLAY_SCALE));
                t.addMouseListener(new MapButtonListener());
                tList.add(t);
              }
              backEnd.addColumn(tList);
              mapWidth++;
            }
            while (targetH > mapHeight) {
              // add new row to backEnd
              List<Tile> tList = new ArrayList<Tile>();
              for (int i = 0; i < mapWidth; i++) {
                Tile t = new Tile(currTileImg, "Test", 0, 0, mov, "none", true, currTileLoc);
                t.setPreferredSize(
                    new Dimension(TILE_SIZE * DISPLAY_SCALE, TILE_SIZE * DISPLAY_SCALE));
                t.addMouseListener(new MapButtonListener());
                tList.add(t);
              }
              backEnd.addRow(tList);
              mapHeight++;
            }

            GridBagConstraints gbc = new GridBagConstraints();

            for (int i = 0; i < mapHeight; i++) {
              gbc.gridy = i;
              for (int j = 0; j < mapWidth; j++) {
                gbc.gridx = j;
                map.add(backEnd.getTile(j, i), gbc);
              }
            }
            map.revalidate();
            map.repaint();
            parentPanel.revalidate();
            parentPanel.repaint();
            ((MapBuilder) SwingUtilities.getWindowAncestor(parentPanel)).pack();
          }
        }
      } catch (NumberFormatException f) {
        JOptionPane.showMessageDialog(null, "Both x and y must be valid integers.");
      }
    }