Ejemplo n.º 1
0
  /**
   * Sets the entities of the map.
   *
   * @param allEntities an array of 3 MapEntity sets: a set for each layer (this array is copied)
   */
  public void setAllEntities(MapEntities[] allEntities) {

    for (Layer layer : Layer.values()) {
      this.allEntities[layer.getId()] = new MapEntities(allEntities[layer.getId()]);
    }

    setChanged();
    notifyObservers();
  }
Ejemplo n.º 2
0
  /**
   * Changes the layer of an entity. You should call this method instead of calling directly
   * MapEntity.setLayer(), because the entity of the 3 layers are stored in 3 different structures.
   * If the entity is not known by the map (yet), this method just calls MapEntity.setLayer().
   *
   * @param entity the entity to change the layer
   * @param layer the new layer
   */
  public void setEntityLayer(MapEntity entity, Layer layer) {

    Layer oldLayer = entity.getLayer();

    if (layer != oldLayer) {
      entity.setLayer(layer);

      if (allEntities[oldLayer.getId()].remove(entity)) {
        allEntities[layer.getId()].add(entity);
      }

      setChanged();
      notifyObservers();
    }
  }
Ejemplo n.º 3
0
 @Override
 public boolean apply(final Layer la, final Area roi, final mpicbg.models.CoordinateTransform ict)
     throws Exception {
   double[] fp = null;
   mpicbg.models.CoordinateTransform chain = null;
   Area localroi = null;
   AffineTransform inverse = null;
   for (final Item item : al_items) {
     final long[] p_layer = item.p_layer;
     final double[][] p = item.p;
     for (int i = 0; i < item.n_points; i++) {
       if (p_layer[i] == la.getId()) {
         if (null == localroi) {
           inverse = this.at.createInverse();
           localroi = roi.createTransformedArea(inverse);
         }
         if (localroi.contains(p[0][i], p[1][i])) {
           if (null == chain) {
             chain = M.wrap(this.at, ict, inverse);
             fp = new double[2];
           }
           // Transform the point
           M.apply(chain, p, i, fp);
         }
       }
     }
   }
   if (null != chain) calculateBoundingBox(la);
   return true;
 }
Ejemplo n.º 4
0
 public Layer getLayer(long id) {
   for (Layer layer : this.layers.values()) {
     if (layer.getId() == id) {
       return layer;
     }
   }
   return null;
 }
Ejemplo n.º 5
0
  /**
   * Changes the tileset of the map.
   *
   * @param tilesetId id of the new tileset, or an empty string to set no tileset
   * @return true if the tileset was loaded successfuly, false if some tiles could not be loaded in
   *     this tileset
   * @throws MapException if this tileset could be applied
   */
  public boolean setTileset(String tilesetId) throws ZSDXException {

    this.badTiles = false;

    // if the tileset is removed
    if (tilesetId.length() == 0 && this.tilesetId.length() != 0) {

      this.tilesetId = tilesetId;
      this.tileset = null;

      setChanged();
      notifyObservers();
    }

    // if the tileset is changed
    else if (!tilesetId.equals(this.tilesetId)) {

      this.tileset = new Tileset(tilesetId);

      for (Layer layer : Layer.values()) {

        LinkedList<MapEntity> entitiesToRemove = new LinkedList<MapEntity>();
        for (MapEntity entity : allEntities[layer.getId()]) {

          try {
            entity.setTileset(tileset);
          } catch (NoSuchTilePatternException ex) {
            // the entity is not valid anymore, we should remove it from the map
            entitiesToRemove.add(entity);
            badTiles = true;
          }
        }

        for (MapEntity entity : entitiesToRemove) {
          allEntities[layer.getId()].remove(entity);
        }
      }

      this.tilesetId = tilesetId;

      setChanged();
      notifyObservers(tileset);
    }

    return !badTiles;
  }
Ejemplo n.º 6
0
  /**
   * Finds all entities of a type on the map.
   *
   * @param entityType a type of entity
   * @return the list of the entities of this kind on the map
   */
  public List<MapEntity> getEntitiesOfType(EntityType entityType) {

    List<MapEntity> list = new LinkedList<MapEntity>();
    for (Layer layer : Layer.values()) {
      list.addAll(allEntities[layer.getId()].getEntitiesOfType(entityType));
    }
    return list;
  }
Ejemplo n.º 7
0
  /** Initializes the object. */
  private void initialize() {
    this.allEntities = new MapEntities[3];
    for (Layer layer : Layer.values()) {
      this.allEntities[layer.getId()] = new MapEntities();
    }

    this.entitySelection = new MapEntitySelection(this);
    this.history = new MapEditorHistory();
  }
Ejemplo n.º 8
0
  /**
   * Returns the total number of active entities of the map.
   *
   * @return the total number of active entities of the map.
   */
  public int getNbDynamicEntities() {

    int nbDynamicEntities = 0;

    // count the dynamic entities of each layer
    for (Layer layer : Layer.values()) {
      nbDynamicEntities += allEntities[layer.getId()].getNbDynamicEntities();
    }

    return nbDynamicEntities;
  }
Ejemplo n.º 9
0
  /**
   * Returns an entity, specifying its type and its name.
   *
   * @param type the type of entity
   * @param name the name of the entity
   * @return the entity, or null if there is no entity with this name
   */
  public MapEntity getEntityWithName(EntityType type, String name) {

    for (Layer layer : Layer.values()) {
      MapEntity entity = allEntities[layer.getId()].getEntityWithName(type, name);
      if (entity != null) {
        return entity;
      }
    }

    return null;
  }
Ejemplo n.º 10
0
 @Override
 public boolean contains(final Layer layer, double x, double y) {
   final long lid = layer.getId();
   final Point2D.Double po = inverseTransformPoint(x, y);
   x = po.x;
   y = po.y;
   for (final Item item : al_items) {
     if (-1 != item.find(lid, x, y, 1)) return true;
   }
   return false;
 }
Ejemplo n.º 11
0
  /**
   * Returns the total number of entities of the map.
   *
   * @return the total number of entities of the map.
   */
  public int getNbEntities() {

    int nbEntities = 0;

    // count the entities of each layer
    for (Layer layer : Layer.values()) {
      nbEntities += allEntities[layer.getId()].size();
    }

    return nbEntities;
  }
Ejemplo n.º 12
0
  /**
   * Returns the highest layer where a specified rectangle overlaps an existing entity.
   *
   * @param rectangle a rectangle
   * @return the highest layer where an entity exists in this rectangle, or Layer.LOW if there is
   *     nothing here
   */
  public Layer getLayerInRectangle(Rectangle rectangle) {

    Layer[] layers = {Layer.HIGH, Layer.INTERMEDIATE, Layer.LOW};
    for (Layer layer : layers) {
      for (MapEntity entity : allEntities[layer.getId()]) {
        if (rectangle.intersects(entity.getPositionInMap())) {
          return layer;
        }
      }
    }
    return Layer.LOW;
  }
Ejemplo n.º 13
0
 // Comparable
 @Override
 public int compareTo(Layer layer) {
   if (priority < layer.priority) {
     return -1;
   } else if (priority > layer.priority) {
     return 1;
   } else if ((layer instanceof GroundCoverLayer)
       && (Math.abs(((GroundCoverLayer) layer).thickness) != Math.abs(thickness))) {
     return Math.abs(((GroundCoverLayer) layer).thickness) - Math.abs(thickness);
   } else {
     return getId().compareTo(layer.getId());
   }
 }
Ejemplo n.º 14
0
  /**
   * Returns the first entity under a point of the map, in the specified layer.
   *
   * @param layer the layer
   * @param x x of the point
   * @param y y of the point
   * @return the entity found, or null if there is no entity here
   */
  public MapEntity getEntityAt(Layer layer, int x, int y) {

    MapEntities entities = allEntities[layer.getId()];
    ListIterator<MapEntity> iterator = entities.listIterator(entities.size());
    while (iterator.hasPrevious()) {

      MapEntity entity = iterator.previous();
      if (entity.containsPoint(x, y)) {
        return entity;
      }
    }

    return null;
  }
Ejemplo n.º 15
0
 /** Retain the data within the layer range, and through out all the rest. */
 @Override
 public synchronized boolean crop(final List<Layer> range) {
   final HashSet<Long> lids = new HashSet<Long>();
   for (final Layer l : range) {
     lids.add(l.getId());
   }
   for (final Item item : al_items) {
     for (int i = 0; i < item.n_points; i++) {
       if (!lids.contains(item.p_layer[i])) {
         item.remove(i);
         i--;
       }
     }
   }
   calculateBoundingBox(null);
   return true;
 }
Ejemplo n.º 16
0
  /**
   * Brings the specified entities to the front, keeping their layer. The order of the specified
   * entities in the map is unchanged.
   *
   * @param entities the entities to move
   */
  public void bringToFront(List<MapEntity> entities) {

    List<MapEntity> sortedEntities = getSortedEntities(entities);

    // bring to front each entity from sortedEntities
    ListIterator<MapEntity> iterator = sortedEntities.listIterator(0);
    while (iterator.hasNext()) {

      MapEntity entity = iterator.next();
      Layer layer = entity.getLayer();
      allEntities[layer.getId()].remove(entity);
      allEntities[layer.getId()].addLast(entity);
    }

    setChanged();
    notifyObservers();
  }
Ejemplo n.º 17
0
  /**
   * Brings the specified entities to the back, keeping their layer. The order of the specified
   * entities in the map is unchanged.
   *
   * @param entities the entities to move
   */
  public void bringToBack(List<MapEntity> entities) {

    List<MapEntity> sortedEntities = getSortedEntities(entities);

    // bring to back each entity from sortedEntities
    ListIterator<MapEntity> iterator = sortedEntities.listIterator(sortedEntities.size());
    while (iterator.hasPrevious()) {

      MapEntity entity = iterator.previous();
      Layer layer = entity.getLayer();
      allEntities[layer.getId()].remove(entity);
      allEntities[layer.getId()].addFirst(entity);
    }

    setChanged();
    notifyObservers();
  }
Ejemplo n.º 18
0
 @Override
 public synchronized Area getAreaAt(final Layer layer) {
   final Area a = new Area();
   for (final Item item : al_items) {
     for (int i = 0; i < item.n_points; i++) {
       if (item.p_layer[i] != layer.getId()) continue;
       a.add(
           new Area(
               new Rectangle2D.Float(
                   (float) (item.p[0][i] - item.radius),
                   (float) (item.p[1][i] - item.radius),
                   item.radius,
                   item.radius)));
     }
   }
   a.transform(this.at);
   return a;
 }
Ejemplo n.º 19
0
 public boolean removeIdentifiable(long id) {
   Collection<Scene> tmpScene = new ArrayList<Scene>();
   tmpScene.addAll(this.scenes);
   for (Scene scene : tmpScene) {
     if (scene.getId() == id) {
       this.removeScene(scene);
       return true;
     }
   }
   List<Layer> tmpLayer = new ArrayList<Layer>();
   tmpLayer.addAll(this.layers.values());
   for (Layer layer : tmpLayer) {
     if (layer.getId() == id) {
       this.removeLayer(layer);
       return true;
     }
   }
   return false;
 }
Ejemplo n.º 20
0
  /**
   * Returns the specified entities, sorted in the order of the map. The first entity is the lowest
   * one, the last entity is the highest one.
   *
   * @param entities the entities to sort
   * @return the same entities, sorted as they are in the map
   */
  public List<MapEntity> getSortedEntities(List<MapEntity> entities) {

    List<MapEntity> sortedEntities = new LinkedList<MapEntity>();

    // sort the entities so that they have the same order as in the map
    for (Layer layer : Layer.values()) {

      for (MapEntity entity : allEntities[layer.getId()]) {

        if (entities.contains(entity)) {
          sortedEntities.add(entity);
        }
      }
    }

    // now sortedEntities contains all entities of the list,
    // sorted in the same order as in the map
    return sortedEntities;
  }
Ejemplo n.º 21
0
  /**
   * Returns the entities located in a rectangle defined by two points.
   *
   * @param x1 x coordinate of the first point
   * @param y1 y coordinate of the first point
   * @param x2 x coordinate of the second point
   * @param y2 y coordinate of the second point
   */
  public List<MapEntity> getEntitiesInRectangle(int x1, int y1, int x2, int y2) {

    List<MapEntity> entitiesInRectangle = new LinkedList<MapEntity>();

    int x = Math.min(x1, x2);
    int width = Math.abs(x2 - x1);

    int y = Math.min(y1, y2);
    int height = Math.abs(y2 - y1);

    Rectangle rectangle = new Rectangle(x, y, width, height);

    for (Layer layer : Layer.values()) {

      for (MapEntity entity : allEntities[layer.getId()]) {
        if (rectangle.contains(entity.getPositionInMap())) {
          entitiesInRectangle.add(entity);
        }
      }
    }

    return entitiesInRectangle;
  }
Ejemplo n.º 22
0
    /**
     * Returns the index of the added point only if: - there are no points, and thus this is the
     * first; - there is no point already for that layer; - the given layer is immediately adjacent
     * (outwards) to that of the first or the last points.
     *
     * <p>Otherwise returns -1
     */
    final int add(final double x, final double y, final Layer layer) {
      final long lid = layer.getId();
      // trivial case
      if (0 == n_points) {
        p[0][0] = x;
        p[1][0] = y;
        p_layer[0] = lid;
        n_points = 1;
        return 0;
      }
      // check if there is already a point for the given layer
      for (int i = 0; i < n_points; i++)
        if (lid == p_layer[i]) {
          return -1;
        }

      final int il = layer_set.indexOf(layer);
      if (layer_set.indexOf(layer_set.getLayer(p_layer[n_points - 1])) == il - 1) {
        // check if new point is within radius of the found point
        if (p[0][n_points - 1] + radius >= x
            && p[0][n_points - 1] - radius <= x
            && p[1][n_points - 1] + radius >= y
            && p[1][n_points - 1] - radius <= y) {
          // ok
        } else {
          // can't add
          // Utils.log2(tag + " case append: can't add");
          return -1;
        }

        // check size
        if (n_points >= p[0].length) enlargeArrays();

        // append at the end
        p[0][n_points] = x;
        p[1][n_points] = y;
        p_layer[n_points] = lid;
        n_points++;
        return n_points - 1;
      }
      if (layer_set.indexOf(layer_set.getLayer(p_layer[0])) == il + 1) {
        // check if new point is within radius of the found point
        if (p[0][0] + radius >= x
            && p[0][0] - radius <= x
            && p[1][0] + radius >= y
            && p[1][0] - radius <= y) {
          // ok
        } else {
          // can't add
          // Utils.log2(tag + " case preppend: can't add");
          return -1;
        }

        // check size
        if (n_points >= p[0].length) enlargeArrays();

        // prepend
        // shift all points one position to the right
        for (int i = n_points - 1; i > -1; i--) {
          p[0][i + 1] = p[0][i];
          p[1][i + 1] = p[1][i];
          p_layer[i + 1] = p_layer[i];
        }
        p[0][0] = x;
        p[1][0] = y;
        p_layer[0] = lid;
        n_points++;
        return 0;
      }
      // else invalid layer
      // Utils.log2(tag + " invalid layer");
      return -1;
    }
Ejemplo n.º 23
0
  @Override
  public void mousePressed(
      final MouseEvent me, final Layer la, int x_p, int y_p, final double mag) {
    final int tool = ProjectToolbar.getToolId();
    if (ProjectToolbar.PEN != tool) return;

    final long lid = la.getId(); // isn't this.layer pointing to the current layer always?

    // transform the x_p, y_p to the local coordinates
    if (!this.at.isIdentity()) {
      final Point2D.Double p = inverseTransformPoint(x_p, y_p);
      x_p = (int) p.x;
      y_p = (int) p.y;
    }

    // find if the click is within radius of an existing point for the current layer
    for (final Item tmp : al_items) {
      index = tmp.find(lid, x_p, y_p, mag);
      if (-1 != index) {
        this.item = tmp;
        break;
      }
    }

    // final boolean is_zoom_invariant = "true".equals(project.getProperty("dissector_zoom"));

    // TODO: if zoom invariant, should check for nearest point. Or nearest point anyway, when
    // deleting
    // (but also for adding a new one?)

    if (me.isShiftDown() && Utils.isControlDown(me)) {
      if (-1 != index) {
        // delete
        item.remove(index);
        if (0 == item.n_points) al_items.remove(item);
        item = null;
        index = -1;
        Display.repaint(layer_set, this, 0);
      }
      // in any case:
      return;
    }
    if (-1 != index) return;
    // else try to add a point to a suitable item
    // Find an item in the previous or the next layer,
    //     which falls within radius of the clicked point
    try {
      for (final Item tmp : al_items) {
        index = tmp.add(x_p, y_p, la);
        if (-1 != index) {
          this.item = tmp;
          return;
        }
      }
      // could not be added to an existing item, so creating a new item with a new point in it
      int max_tag = 0;
      for (final Item tmp : al_items) {
        if (tmp.tag > max_tag) max_tag = tmp.tag;
      }
      int radius = 8; // default
      if (al_items.size() > 0) radius = al_items.get(al_items.size() - 1).radius;
      this.item = new Item(max_tag + 1, radius, x_p, y_p, la);
      index = 0;
      al_items.add(this.item);
    } finally {
      if (null != item) {
        bbox = this.at.createTransformedShape(item.getBoundingBox()).getBounds();
        Display.repaint(layer_set, bbox);
      } else Display.repaint(layer_set, this, 0);
    }
  }
Ejemplo n.º 24
0
 @Override
 protected boolean layerRemoved(final Layer la) {
   super.layerRemoved(la);
   for (final Item item : al_items) item.layerRemoved(la.getId());
   return true;
 }
Ejemplo n.º 25
0
  /**
   * Saves the map into its file.
   *
   * @throws ZSDXException if the file could not be written for various reasons
   */
  public void save() throws ZSDXException {

    // check that the map is valid
    checkValidity();

    try {

      // open the map file
      File mapFile = Project.getMapFile(mapId);
      PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(mapFile)));

      // print the map general info
      // syntax: width height world floor x y small_keys_variable tileset_id music_id
      out.print(size.width);
      out.print('\t');
      out.print(size.height);
      out.print('\t');
      out.print(world);
      out.print('\t');
      out.print(floor);
      out.print('\t');
      out.print(location.x);
      out.print('\t');
      out.print(location.y);
      out.print('\t');
      out.print(smallKeysVariable);
      out.print('\t');
      out.print(tilesetId);
      out.print('\t');
      out.print(musicId);
      out.println();

      for (Layer layer : Layer.values()) {

        MapEntities entities = allEntities[layer.getId()];

        // print the entities
        for (MapEntity entity : entities) {
          out.print(entity.toString());
          out.println();
        }
      }

      out.close();

      history.setSaved();

      // also update the map name in the global resource list
      Resource mapResource = Project.getResource(ResourceType.MAP);
      mapResource.setElementName(mapId, name);
      Project.getResourceDatabase().save();

      // upate the dungeon elements of this map
      if (isInDungeon()) {
        Dungeon.saveMapInfo(this);
      }

      // create a script for the map if necessary
      File scriptFile = Project.getMapScriptFile(mapId);
      if (!scriptFile.exists()) {
        scriptFile.createNewFile();
      }
    } catch (IOException ex) {
      throw new MapException(ex.getMessage());
    }
  }
Ejemplo n.º 26
0
 /**
  * Returns the entities of the map on a given layer.
  *
  * @param layer the layer
  * @return the entities placed on that layer
  */
 public MapEntities getEntities(Layer layer) {
   return allEntities[layer.getId()];
 }