game_object.hpp

//  SuperTux
//  Copyright (C) 2006 Matthias Braun <matze@braunis.de>
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <http://www.gnu.org/licenses/>.

#ifndef HEADER_SUPERTUX_SUPERTUX_GAME_OBJECT_HPP
#define HEADER_SUPERTUX_SUPERTUX_GAME_OBJECT_HPP

#include "squirrel/exposable_class.hpp"

#include <algorithm>
#include <string>
#include <vector>
#include <typeindex>

#include "editor/object_settings.hpp"
#include "supertux/game_object_component.hpp"
#include "util/fade_helper.hpp"
#include "util/gettext.hpp"
#include "util/uid.hpp"

class DrawingContext;
class GameObjectComponent;
class GameObjectManager;
class ObjectRemoveListener;
class ReaderMapping;
class Writer;

namespace ssq {
class VM;
} // namespace ssq

struct GameObjectType
{
  const std::string id;
  const std::string name;
};
typedef std::vector<GameObjectType> GameObjectTypes;

struct GameObjectClasses
{
  std::vector<std::type_index> types;

  GameObjectClasses& add(const std::type_info& info)
  {
    std::type_index idx(info);
    types.push_back(idx);
    return *this;
  }
};

class GameObject : public ExposableClass
{
  friend class GameObjectManager;

public:
  static void register_class(ssq::VM& vm);

public:
  GameObject();
  GameObject(const std::string& name);
  GameObject(const ReaderMapping& reader);
  virtual ~GameObject() override;

  virtual void finish_construction() {}

  UID get_uid() const { return m_uid; }

  virtual void update(float dt_sec) = 0;

  virtual void draw(DrawingContext& context) = 0;

  virtual void save(Writer& writer);
  std::string save();
  virtual std::string get_class_name() const { return "game-object"; }
  virtual std::string get_exposed_class_name() const override { return "GameObject"; }
  virtual std::string get_display_name() const { return _("Unknown object"); }
  virtual GameObjectClasses get_class_types() const;

  virtual std::vector<std::string> get_patches() const;
  virtual void update_version();
  int get_version() const;
  int get_latest_version() const;
  bool is_up_to_date() const;

  virtual bool is_singleton() const { return false; }

  virtual bool has_variable_size() const { return false; }

  virtual bool is_saveable() const { return true; }

  virtual bool track_state() const { return true; }

  virtual bool has_object_manager_priority() const { return false; }

  virtual bool has_settings() const { return is_saveable(); }
  virtual ObjectSettings get_settings();

  virtual GameObjectTypes get_types() const;
  int get_type() const;

  virtual void after_editor_set();

  virtual void on_flip(float height) {}

  virtual void remove_me() { m_scheduled_for_removal = true; }

  bool is_valid() const { return !m_scheduled_for_removal; }

  void add_remove_listener(ObjectRemoveListener* listener);

  void del_remove_listener(ObjectRemoveListener* listener);

  void set_name(const std::string& name) { m_name = name; }
  const std::string& get_name() const;

  virtual const std::string get_icon_path() const {
    return "images/tiles/auxiliary/notile.png";
  }

  virtual void stop_looping_sounds() {}

  virtual void play_looping_sounds() {}

  template<typename T>
  T* get_component() {
    for(auto& component : m_components) {
      if (T* result = dynamic_cast<T*>(component.get())) {
        return result;
      }
    }
    return nullptr;
  }

  void add_component(std::unique_ptr<GameObjectComponent> component) {
    m_components.emplace_back(std::move(component));
  }

  void remove_component(GameObjectComponent* component) {
    auto it = std::find_if(m_components.begin(), m_components.end(),
                           [component](const std::unique_ptr<GameObjectComponent>& lhs){
                             return lhs.get() == component;
                           });
    if (it != m_components.end()) {
      m_components.erase(it);
    }
  }

  virtual void save_state();
  virtual void check_state();

  virtual void editor_delete() { remove_me(); }

  virtual void editor_select() {}

  virtual void editor_deselect() {}

  virtual void editor_update() {}

  GameObjectManager* get_parent() const { return m_parent; }

protected:
  void parse_type(const ReaderMapping& reader);

  enum TypeChange { INITIAL = -1 }; // "old_type < 0" indicates initial call
  virtual void on_type_change(int old_type) {}

  int type_id_to_value(const std::string& id) const;
  std::string type_value_to_id(int value) const;

private:
  void set_uid(const UID& uid) { m_uid = uid; }

private:
  GameObjectManager* m_parent;

protected:
  std::string m_name;

  int m_type;

  std::vector<std::unique_ptr<FadeHelper>> m_fade_helpers;

  bool m_track_undo;

private:
  int m_previous_type;

  int m_version;

  UID m_uid;

  bool m_scheduled_for_removal;

  std::string m_last_state;

  std::vector<std::unique_ptr<GameObjectComponent> > m_components;

  std::vector<ObjectRemoveListener*> m_remove_listeners;

private:
  GameObject(const GameObject&) = delete;
  GameObject& operator=(const GameObject&) = delete;
};

#endif

/* EOF */