cronous-env.hh

説明を見る。

#ifndef CRONOUS_ENV_HH_
# define CRONOUS_ENV_HH_

# include <map>
# include <list>

# include "infos_fwd.hh"
# include "objects_fwd.hh"
# include "packets_fwd.hh"
# include "connection_fwd.hh"
# include "environment_fwd.hh"
# include "rxtools_fwd.hh"
# include "characters_available.hh"
# include "items.hh"
# include "tasks_fwd.hh"
# include "skills.hh"
# include "events.hh"

# define DEST_RANGE_X 10
# define DEST_RANGE_Y 10
# define DEST_RANGE_Z 1
# define MOTION_RANGE_X 3
# define MOTION_RANGE_Y 3
# define MOTION_RANGE_Z 1

namespace environment
{
  class CronousEnv : public events::EventManager
  {
  public:
    enum EventID
    {
      event_chat = 0x00,
      event_motion = 0x01
    };

  public:
    enum State
    {
      state_news,
      state_login,
      state_select_character,
      state_start_character,
      state_game
    };
    typedef std::map<int, objects::Character *> IntToCharacterMap;
    typedef std::map<std::string, objects::Character *> StringToCharacterMap;
    typedef std::list<int> IntList;
    typedef std::set<int> IntSet;
    typedef std::set<const objects::HealingItem *> HealingItemSet;

  public: // Common.
    CronousEnv();
    ~CronousEnv();

    static CronousEnv &get_instance();
    static bool initialized();
    static void restart();

    // Control the packet protocol with _state/_substate.
    void process_read(connection::ServerConnection &sc);
    void report_packet_sent(connection::ServerConnection &sc,
      packets::DataPacket &p);
    void report_packet_received(connection::ServerConnection &sc,
      packets::DataPacket &p);

    const infos::CharactersAvailable *get_characters_available() const;
    const infos::CharactersAvailable::CharactersType &get_characters() const;
    void set_characters_available(infos::CharactersAvailable &);

    int get_state() const;
    void change_state(int state);
    int get_substate() const;
    void set_substate(int s);

  protected:
    int _state;
    int _substate;
    infos::CharactersAvailable *_characters_available;
    infos::CharactersAvailable::CharactersType *_characters;
    void time_report();

  public: // Position & map.
    int get_pos_x() const;
    int get_pos_y() const;
    int get_pos_z() const;
    void set_pos_x(int x);
    void set_pos_y(int y);
    void set_pos_z(int z);
    int get_dest_x() const;
    int get_dest_y() const;
    int get_dest_z() const;
    void set_dest_x(int x);
    void set_dest_y(int y);
    void set_dest_z(int z);
    void start_pos_report();
    bool is_moving() const;
    int get_angle() const;
    void set_angle(int degrees);

    // Map related.
    const objects::DefMap *get_current_map() const;
    void set_current_map(const objects::DefMap &map);
    const objects::DefMap *get_scroll_map() const;
    void set_scroll_map(const objects::DefMap &map);
    const objects::DefMap *get_home_map() const;
    void set_home_map(const objects::DefMap &map);
    bool is_warping() const;
    void set_warping(bool b);

    // Node related.
    void set_dest_node(const objects::MapNode &n);
    int calculate_distance(const objects::MapNode &mn) const;

  protected:
    int _pos_x;
    int _pos_y;
    int _pos_z;
    int _dest_x;
    int _dest_y;
    int _dest_z;
    int _angle;
    rxtimer::RxTimer *_pos_report_timer;
    const objects::DefMap *_current_map;
    const objects::DefMap *_scroll_map;
    const objects::DefMap *_home_map;
    bool _warping;

  public: // Objects in screen.
    objects::Character *get_character(int id);
    objects::Character *get_character(std::string name);
    objects::Character *get_screen_character(int id);
    void add_character(objects::Character *c);
    void add_character_to_screen(objects::Character *c);
    void remove_character_from_screen(int id);
    const IntToCharacterMap &get_id_map() const;
    const IntToCharacterMap &get_screen_id_map() const;
    const StringToCharacterMap &get_name_map() const;
    objects::Character *get_player_character() const;

    int calculate_distance(const objects::Character &c) const;
    objects::Character *get_closest_npc();
    
  protected:
    IntToCharacterMap _id_map;
    IntToCharacterMap _screen_id_map;
    StringToCharacterMap _name_map;
    objects::Character *_player_character;

  public: // Character status.
    int get_status_flag() const;
    void set_status_flag(int i);
    bool get_can_attack() const;
    void set_can_attack(bool can);
    const std::string &get_name() const;
    int get_class() const;
    int get_level() const;
    int get_str_status_points() const;
    int get_sta_status_points() const;
    int get_dex_status_points() const;
    int get_int_status_points() const;
    int get_fame() const;
    int get_free_status_points() const;
    int get_free_skill_points() const;
    int get_money_in_hand() const;
    int get_money_in_bank() const;
    void set_name(const std::string &s);
    void set_class(int i);
    void set_level(int i);
    void set_str_status_points(int i);
    void set_sta_status_points(int i);
    void set_dex_status_points(int i);
    void set_int_status_points(int i);
    void set_fame(int i);
    void set_free_status_points(int i);
    void set_free_skill_points(int i);
    void set_money_in_hand(int i);
    void set_money_in_bank(int i);

    void push_assigned_status(int status_id);
    void report_status_assigning(int code);
    void check_support_skills();

    bool get_alive() const;
    void set_alive(bool alive);

  protected:
    int _status_flag;
    bool _can_attack;
    bool _alive;

    std::string _name;
    int _class;
    int _level;
    int _str_status_points;
    int _sta_status_points;
    int _dex_status_points;
    int _int_status_points;
    int _fame;
    int _free_status_points;
    int _free_skill_points;
    int _money_in_hand;
    int _money_in_bank;

    IntList _assigned_status;

  public: // Status (emulation).
    int get_hp() const;
    int get_mp() const;
    int get_weight() const;
    void set_hp(int i);
    void set_mp(int i);
    void set_weight(int i);
    int get_hp_max() const;
    int get_mp_max() const;
    void set_hp_max(int i);
    void set_mp_max(int i);
    int get_weight_max() const;
    void set_weight_max(int i);

    double get_experience() const;
    void set_experience(double d);

  protected:
    int _hp;
    int _mp;
    int _weight;
    int _hp_max;
    int _mp_max;
    int _weight_max;
    double _experience;

  public: // Skills
    objects::Skills &get_skills();

    void push_skill_id(int id);
    void assign_skill_level(int level);

    void push_assigned_skill(int skill_id);
    void report_skill_assigning(int code);

    bool can_use_skill() const;
    void report_skill_using(int skill_id, objects::Character &c);
    void push_auto_skill(int skill_id);
    void use_auto_skill();

  protected:
    objects::Skills _skills;
    IntList _skill_list;
    IntList _assigned_skill;
    IntSet _auto_skills;

  public: // Inventory.
    const objects::Items &get_items() const;
    objects::Items &get_items();
    int calculate_distance(const objects::ItemInScreen &iis) const;
    int get_last_item_info() const;
    void set_last_item_info(int id);

    // Item manipulation.
    void push_sold_item(int item_id);
    void report_selling(int code);
    int count_sold_items_in_queue();
    void push_used_item(int item_id);
    void report_using(int code);
    int count_used_items_in_queue();
    void push_repaired_item(int item_id);
    void report_repairing(int code);
    int count_repaired_items_in_queue();
    void push_traded_item(int item_id);
    void report_trading(int code);
    int count_traded_items_in_queue();
    void push_picked_item(int item_id);
    void report_picking(int code);
    int count_picked_items_in_queue();

    // Stats.
    int get_amount_of_hp_healed() const;
    int get_amount_of_mp_healed() const;
    void reset_healing_stats();
    void report_healing(const objects::HealingItem &hi);

    // Shortcuts.
    const objects::HealingItem &get_hp_healing_item() const;
    const objects::HealingItem &get_mp_healing_item() const;
    objects::PossessedItem *get_best_hp_healing_item_in_hand(bool force);
    objects::PossessedItem *get_best_mp_healing_item_in_hand(bool force);
    void warp();

  protected:
    objects::Items _items;
    IntList _sold_items;
    IntList _used_items;
    IntList _repaired_items;
    IntList _traded_items;
    IntList _picked_items;
    int _amount_of_hp_healed;
    int _amount_of_mp_healed;
    int _last_item_info;

  public: // Chat.
    const std::string &get_last_chat_message() const;
    const std::string &get_last_chat_character() const;
    void set_last_chat_message(const std::string &message);
    void set_last_chat_character(const std::string &character);
    void trim_chat_message(std::string &message);

  protected:
    std::string _last_chat_message;
    std::string _last_chat_character;

  public: // Personal shop.
    void push_shop_item(int item_id);
    int count_shop_item_in_queue() const;
    void report_shop_item(int code);

  protected:
    IntList _shop_items;

  public: // Tasks, AI.
    const tasks::Activity &get_current_activity() const;
    bool start_activity(tasks::Activity &activity);

  protected:
    tasks::Activity *_current_activity;

  public: // GUI related.
    void add_possessed_item_to_gui(objects::PossessedItem &pi);
    void add_possessed_item_to_gui(objects::PossessedItem &pi, int proto_id);
  };
}

# include "cronous-env.hxx"

#endif

---