C++ MapEntity::get_layer方法代码示例

/**
 * \brief Checks whether a sprite collides with this detector.
 *
 * If there is a collision, the notify_collision(MapEntity&, Sprite&, Sprite&) method is called.
 *
 * \param entity the entity to check
 * \param sprite the sprite of that entity
 */
void Detector::check_collision(MapEntity& entity, Sprite& sprite) {

  if (has_collision_mode(COLLISION_SPRITE)
      && &entity != this
      && (has_layer_independent_collisions() || get_layer() == entity.get_layer())) {

    // we check the collision between the specified entity's sprite and all sprites of the current entity
    std::vector<Sprite*>::const_iterator it;
    for (it = get_sprites().begin(); it != get_sprites().end(); it++) {
      Sprite& this_sprite = *(*it);

      if (this_sprite.test_collision(sprite, get_x(), get_y(), entity.get_x(), entity.get_y())) {
        notify_collision(entity, sprite, this_sprite);
      }
    }
  }
}

/**
 * @brief Removes and destroys the entities placed in the entities_to_remove list. 
 */
void MapEntities::remove_marked_entities() {

  list<MapEntity*>::iterator it;

  // remove the marked entities
  for (it = entities_to_remove.begin();
       it != entities_to_remove.end();
       it++) {

    MapEntity *entity = *it;
    Layer layer = entity->get_layer();

    // remove it from the obstacle entities list if present
    if (entity->can_be_obstacle()) {

      if (entity->has_layer_independent_collisions()) {
	for (int i = 0; i < LAYER_NB; i++) {
	  obstacle_entities[i].remove(entity);
	}
      }
      else {
        obstacle_entities[layer].remove(entity);
      }
    }

    // remove it from the detectors list if present
    if (entity->can_detect_entities()) {
      detectors.remove((Detector*) entity);
    }

    // remove it from the sprite entities list if present
    if (entity->is_displayed_in_y_order()) {
      entities_displayed_y_order[layer].remove(entity);
    }
    else if (entity->can_be_displayed()) {
      entities_displayed_first[layer].remove(entity);
    }

    // remove it from the whole list
    all_entities.remove(entity);

    // destroy it
    delete entity;
  }
  entities_to_remove.clear();
}

/**
 * \brief Changes the layer of an entity.
 *
 * Only some specific entities should change their layer.
 *
 * \param entity an entity
 * \param layer the new layer
 */
void MapEntities::set_entity_layer(MapEntity& entity, Layer layer) {

  Layer old_layer = entity.get_layer();

  if (layer != old_layer) {

    // update the obstacle list
    if (entity.can_be_obstacle() && !entity.has_layer_independent_collisions()) {
      obstacle_entities[old_layer].remove(&entity);
      obstacle_entities[layer].push_back(&entity);
    }

    // update the ground observers list
    if (entity.is_ground_observer()) {
      ground_observers[old_layer].remove(&entity);
      ground_observers[layer].push_back(&entity);
    }

    // update the ground modifiers list
    if (entity.is_ground_modifier()) {
      ground_modifiers[old_layer].remove(&entity);
      ground_modifiers[layer].push_back(&entity);
    }

    // update the sprites list
    if (entity.is_drawn_in_y_order()) {
      entities_drawn_y_order[old_layer].remove(&entity);
      entities_drawn_y_order[layer].push_back(&entity);
    }
    else if (entity.can_be_drawn()) {
      entities_drawn_first[old_layer].remove(&entity);
      entities_drawn_first[layer].push_back(&entity);
    }

    // update the entity after the lists because this function might be called again
    entity.set_layer(layer);
  }
}

/**
 * \brief Removes and destroys the entities placed in the entities_to_remove list.
 */
void MapEntities::remove_marked_entities() {

  list<MapEntity*>::iterator it;

  // remove the marked entities
  for (it = entities_to_remove.begin();
       it != entities_to_remove.end();
       it++) {

    MapEntity* entity = *it;
    Layer layer = entity->get_layer();

    // remove it from the obstacle entities list if present
    if (entity->can_be_obstacle()) {

      if (entity->has_layer_independent_collisions()) {
        for (int i = 0; i < LAYER_NB; i++) {
          obstacle_entities[i].remove(entity);
        }
      }
      else {
        obstacle_entities[layer].remove(entity);
      }
    }

    // remove it from the detectors list if present
    if (entity->is_detector()) {
      detectors.remove(static_cast<Detector*>(entity));
    }

    // remove it from the ground obsevers list if present
    if (entity->is_ground_observer()) {
      ground_observers[layer].remove(entity);
    }

    // remove it from the ground modifiers list if present
    if (entity->is_ground_modifier()) {
      ground_modifiers[layer].remove(entity);
    }

    // remove it from the sprite entities list if present
    if (entity->is_drawn_in_y_order()) {
      entities_drawn_y_order[layer].remove(entity);
    }
    else if (entity->can_be_drawn()) {
      entities_drawn_first[layer].remove(entity);
    }

    // remove it from the whole list
    all_entities.remove(entity);
    const std::string& name = entity->get_name();
    if (!name.empty()) {
      named_entities.erase(name);
    }

    // update the specific entities lists
    switch (entity->get_type()) {

      case STAIRS:
        stairs[layer].remove(static_cast<Stairs*>(entity));
        break;

      case CRYSTAL_BLOCK:
        crystal_blocks[layer].remove(static_cast<CrystalBlock*>(entity));
        break;

      case SEPARATOR:
        separators.remove(static_cast<Separator*>(entity));
        break;

      case BOOMERANG:
        this->boomerang = NULL;
        break;

      default:
      break;
    }

    // destroy it
    destroy_entity(entity);
  }
  entities_to_remove.clear();
}