#include <ZoneClientInterface.hpp>

Inheritance diagram for Horizon::Zone::ZoneClientInterface:

Collaboration diagram for Horizon::Zone::ZoneClientInterface:

Public Member Functions
	ZoneClientInterface (std::shared_ptr< ZoneSession > s)

	~ZoneClientInterface ()

UI::Chatroom &	chatroom ()

UI::Trade &	trade ()

UI::Party &	party ()

UI::PartyBooking &	party_booking ()

UI::Guild &	guild ()

UI::Friend &	friend_ ()

UI::Quest &	quest ()

UI::Auction &	auction ()

UI::Mail &	mail ()

UI::Clan &	clan ()

bool	login (uint32_t account_id, uint32_t char_id, uint32_t auth_code, uint32_t client_time, uint8_t gender)

bool	restart (uint8_t type)
	All cleanups are managed in ZoneSocket::perform_cleanup. More...

bool	disconnect (int8_t type)

bool	update_session (int32_t account_id, bool first=true)

bool	walk_to_coordinates (uint16_t x, uint16_t y, uint8_t dir)

bool	notify_time ()

bool	notify_unit_name (uint32_t guid)

bool	stop_attack ()

void	request_name_by_char_id (int char_id)
	Character. More...

void	invite_baby (int account_id)

void	pvpinfo (int character_id, int account_id)

void	ranking (cz_req_ranking_type type)
	Ranking. More...

void	ranking_alchemist ()

void	ranking_blacksmith ()

void	ranking_pk ()

bool	notify_pvp_points ()

bool	notify_ranking (cz_req_ranking_type type, std::vector< zc_ack_ranking_info > info, int ranking_points)

void	set_config (cz_config_type config, bool setting)
	Config. More...

void	view_equipment (int account_id)

bool	notify_player_movement (int32_t time, MapCoords from, MapCoords to)

bool	notify_movement_stop (int32_t guid, int16_t x, int16_t y)

bool	notify_unit_move (int32_t guid, int32_t time, MapCoords from, MapCoords to)

item_viewport_entry	create_viewport_item_entry (std::shared_ptr< Units::Item > item)

unit_viewport_entry	create_viewport_entry (std::shared_ptr< Unit > unit)

bool	notify_viewport_add_unit (unit_viewport_entry entry)

bool	notify_viewport_remove_unit (std::shared_ptr< Unit > unit, unit_viewport_notification_type type)

bool	notify_viewport_moving_unit (unit_viewport_entry entry)

bool	notify_viewport_spawn_unit (unit_viewport_entry entry)

bool	notify_viewport_item_entry (item_viewport_entry entry)

void	npc_weapon_refine (int32_t inventory_index)
	NPC. More...

void	npc_next_dialog (int32_t npc_guid)

void	npc_contact (int32_t npc_guid)

void	npc_close (int32_t npc_guid)

void	notify_npc_dialog (uint32_t npc_guid, std::string dialog)

void	notify_npc_next_dialog (uint32_t npc_guid)

void	notify_npc_close_dialog (uint32_t npc_guid)

void	notify_npc_menu_list (uint32_t npc_guid, std::string const &menu)

uint32_t	get_npc_contact_guid ()

void	set_npc_contact_guid (uint32_t guid)

void	npc_select_deal_type (int guid, cz_ack_select_dealtype deal_type)

void	npc_select_menu (int guid, int choice)

void	npc_input (int guid, int value)

void	npc_input (int guid, std::string value)

void	npc_purchase_items (std::vector< cz_pc_purchase_itemlist > items)

void	npc_sell_items (std::vector< cz_pc_sell_itemlist > items)

void	vending_purchase_items (int account_id, std::vector< cz_pc_purchase_itemlist > items)

void	vending_purchase_items (int account_id, int unique_id, std::vector< cz_pc_purchase_itemlist > items)

void	progress_bar_completed ()

bool	notify_initial_status ()
	Status. More...

bool	notify_appearance_update (unit_appearance_type type, int32_t value, int32_t value2)

bool	notify_compound_attribute_update (status_point_type type, int32_t value)

bool	notify_status_attribute_update (status_point_type type, int32_t value, bool success)

bool	notify_required_attribute_update (status_point_type type, int32_t value)

bool	notify_attribute_update (status_point_type type, int32_t value, int32_t value2)

bool	notify_cart_weight_update ()

bool	notify_attack_range_update (int32_t value)

bool	notify_experience_update (status_point_type type, int32_t value)

bool	notify_zeny_update ()

bool	increase_status_point (status_point_type type, uint8_t amount)

void	register_baby (int account_id, int character_id, cz_join_baby_reply_type response)

void	auto_revive ()

bool	notify_move_to_map (std::string map_name, int16_t x, int16_t y)
	Map. More...

void	map_enter ()

bool	notify_map_properties (zc_map_properties properties)

bool	notify_chat (std::string message)
	Chat. More...

void	parse_chat_message (std::string message)

void	whisper_message (const char name, int32_t name_length, const char message, int32_t message_length)

void	use_item (int16_t inventory_index, int32_t guid)
	Items. More...

void	equip_item (int16_t inventory_index, int16_t equip_location_mask)

void	pickup_item (int guid)

void	unequip_item (int16_t inventory_index)

void	throw_item (int16_t inventory_index, int16_t amount)

void	move_item_from_inventory_to_cart (int16_t inventory_index, int amount)

void	move_item_from_inventory_to_storage (int16_t inventory_index, int amount)

void	move_item_from_cart_to_inventory (int16_t inventory_index, int amount)

void	move_item_from_cart_to_storage (int16_t inventory_index, int amount)

void	move_item_from_storage_to_inventory (int16_t storage_index, int amount)

void	move_item_from_storage_to_cart (int16_t inventory_index, int amount)

void	display_item_card_composition (int card_index, int equip_index=0)

void	repair_item (int inventory_index, int item_id, int refine, int card1, int card2, int card3, int card4)

void	identify_item (int inventory_index)

bool	notify_pickup_item (std::shared_ptr< item_entry_data > item, int16_t amount, item_inventory_addition_notif_type result)

bool	notify_normal_item_list (std::vector< std::shared_ptr< const item_entry_data > > const &items)

bool	notify_equipment_item_list (std::vector< std::shared_ptr< const item_entry_data > > const &items)

bool	notify_throw_item (int16_t inventory_index, int16_t amount)

bool	notify_inventory_move_failed (int16_t inventory_index, bool silent)

bool	notify_delete_item (int16_t inventory_index, int16_t amount, item_deletion_reason_type reason)

bool	notify_bind_on_equip (int16_t inventory_index)

bool	notify_use_item (std::shared_ptr< item_entry_data > inv_item, bool success)

bool	notify_equip_item (std::shared_ptr< const item_entry_data > item, item_equip_result_type result)

bool	notify_unequip_item (std::shared_ptr< const item_entry_data > item, item_unequip_result_type result)

bool	notify_equip_arrow (std::shared_ptr< const item_entry_data > item)

bool	notify_action_failure (int16_t message_type)

bool	notify_item_composition (int16_t item_inventory_index, int16_t card_inventory_index, zc_ack_item_composition_result_type result)

bool	notify_identified_item (int16_t inventory_index, zc_ack_item_identify_result_type result)

bool	notify_item_refining (zc_ack_itemrefining_result_type result, int16_t inventory_index, int16_t refine_lv)

bool	notify_item_repair (int inventory_index, zc_ack_itemrepair_result_type result)

bool	notify_item_merge (int inventory_index, int amount, zc_ack_merge_item_reason_type reason)

bool	notify_item_drop (int guid, int item_id, int type, int identified, int x, int y, int x_area, int y_area, int amount, int show_drop_effect=0, int drop_effect_mode=0)

bool	notify_item_removal_from_floor (int guid)

bool	notify_inventory_start (inventory_type type, std::string name)
	Inventory Start / End. More...

bool	notify_inventory_end (inventory_type type)

void	storage_close ()
	Storage. More...

bool	notify_storage_size (int16_t total_size, int16_t max_size)

bool	notify_storage_normal_items (std::string name, std::vector< std::shared_ptr< const item_entry_data > > const &items)

bool	notify_storage_equip_items (std::string name, std::vector< std::shared_ptr< const item_entry_data > > const &items)

bool	notify_storage_close ()

bool	notify_storage_add_item (std::shared_ptr< const item_entry_data > entry, int amount)

bool	notify_storage_remove_item (int16_t storage_index, int amount)

void	upgrade_skill_level (int16_t skill_id)
	Skills. More...

bool	notify_learnt_skill_list ()

bool	notify_skill_fail (int16_t skill_id, int32_t message_type, int32_t item_id, skill_use_fail_cause_type cause)

void	use_skill_on_target (int16_t skill_lv, int16_t skill_id, int target_guid)

void	use_skill_on_ground (int16_t skill_lv, int16_t skill_id, int16_t pos_x, int16_t pos_y)

void	use_skill_on_ground (int16_t skill_lv, int16_t skill_id, int16_t pos_x, int16_t pos_y, std::string contents)

void	notify_skill_cast (uint16_t skill_id, uint32_t src_guid, uint32_t target_guid, uint16_t target_x, uint16_t target_y, uint32_t element, int cast_time)

void	notify_safe_skill_use (int skill_id, int heal_amount, int target_guid, zc_use_skill2_result_type result)

void	notify_hostile_skill_use (int16_t skill_id, int32_t src_guid, int32_t target_guid, int32_t start_time, int32_t attack_motion, int32_t delay_motion, int32_t damage, int16_t level, int16_t count, int8_t action)

void	action_request (int32_t target_guid, player_action_type action)

bool	notify_action (player_action_type action)

bool	notify_action (int32_t target_guid, player_action_type action)

void	setting_effects (int setting)
	Status. More...

bool	notify_status_change (int16_t si_type, int32_t guid, int8_t state, int32_t time_remaining, int32_t val1, int32_t val2, int32_t val3)

bool	notify_status_change_end (int16_t status_index, int32_t guid, int8_t state)

bool	notify_damage (int guid, int target_guid, int start_time, int delay_skill, int delay_damage, int damage, bool is_sp_damaged, int number_of_hits, int8_t action_type, int left_damage)
	Combat. More...

void	storage_check_password (std::string password)
	Storage. More...

void	storage_change_password (std::string password, std::string new_password)

void	open_vend_shop (int account_id)
	Vending. More...

void	close_vending ()

void	open_buying_store (int account_id)

void	close_buying_store ()

void	start_vending (std::string shop_name, std::vector< cz_req_openstore_itemlist > items)

void	start_buying_store (std::string store_name, int zeny_limit, std::vector< cz_req_open_buying_store_itemlist > items)

void	sell_to_buying_store (int account_id, int store_id, std::vector< cz_req_trade_buying_store_itemlist > items)

bool	notify_buying_store_itemlist (int account_id, int store_id, int zeny_limit, std::vector< zc_ack_itemlist_buying_store > items)

bool	notify_open_vending (zc_ack_openstore2_result_type result)

void	emotion (int type)
	Misc. More...

void	user_count ()

void	ignore_list ()

void	star_gladiator_feel_save (cz_agree_starplace_type type)
	Class Specific. More...

void	novice_explosion_spirits ()

void	novice_doridori ()

void	remember_warppoint ()

void	produce_item (int item_id, std::vector< int16_t > material_ids)

void	remove_cart ()

void	change_cart (int16_t num)

void	make_arrow (int16_t item_id)

void	make_item (cz_req_makingitem_type type, int16_t item_id)

void	message (std::string message)
	Battlegrounds. More...

void	blocking_play_cancel ()

void	client_version (int version)

void	broadcast (std::string message)

void	broadcast_local (std::string message)

void	change_direction (int head_direction, int body_direction)

void	change_effect_state (int effect_state)

void	change_map_type (int x, int y, bool walkable)

void	bargain_sale_tool_close ()

void	searchstore_close ()

void	command_mercenary (int type, cz_command_mercenary_command_type command)
	Pet. More...

void	command_pet (cz_command_pet_type command)

void	pet_act_emotion (cz_pet_act_emotion_type emotion)

void	pet_evolve (int evolved_pet_egg_id, std::vector< cz_pet_evolution_itemlist > items)

void	rename_homunculus (std::string name)

void	rename_pet (std::string name)

void	request_action (int guid, int target_id, int action)

void	move_homunculus_to_coordinates (int guid, int x, int y, int dir)

void	move_homunculus_to_master (int guid)

void	disconnect_all_players ()
	Administration. More...

void	disconnect_account (int account_id)

void	create (std::string create)

void	move_to_map (std::string map_name, int16_t x, int16_t y)

void	recall (std::string username)

void	recall (int account_id)

void	summon (std::string char_name)

void	warp_to (int account_id)

void	request_username (int account_id)

void	adjust_manner_by_name (std::string name)

void	give_manner_point (int account_id, cz_req_give_manner_point_type type, int value)

void	check_status (std::string name)

bool	notify_give_manner_point (zc_ack_give_manner_point_result_type result)

void	memorial_dungeon_command (cz_memorial_dungeon_command_type command)
	Instancing. More...

void	cash_point_purchase (int kafra_points, std::vector< cz_pc_buy_cash_point_item > items)
	Cash Point Store. More...

void	private_airship_request (std::string map_name, int item_id)

bool	notify_resurrection (int32_t guid, int type)

bool	notify_recovery (zc_notify_recovery_type type, int amount)

Public Member Functions inherited from Horizon::ClientInterface< ZoneSession >
	ClientInterface (std::shared_ptr< ZoneSession > s)

	~ClientInterface ()

std::shared_ptr< ZoneSession >	get_session ()

void	set_session (std::shared_ptr< ZoneSession > s)

Protected Attributes
uint32_t	_npc_contact_guid {0}

UI::Chatroom	_chat_room

UI::Trade	_trade

UI::Party	_party

UI::Guild	_guild

UI::Friend	_friend

UI::Quest	_quest

UI::Auction	_auction

UI::Mail	_mail

UI::Clan	_clan

UI::PartyBooking	_party_booking

Constructor & Destructor Documentation

◆ ZoneClientInterface()

ZoneClientInterface::ZoneClientInterface ( std::shared_ptr< ZoneSession > s )

: ClientInterface(s), _chat_room(s), _trade(s), _party(s), _guild(s), _friend(s), _quest(s), 
  _auction(s), _mail(s), _clan(s), _party_booking(s)
{
    
}

◆ ~ZoneClientInterface()

ZoneClientInterface::~ZoneClientInterface ( )

65{

66}

Member Function Documentation

◆ action_request()

void ZoneClientInterface::action_request	(	int32_t	target_guid,
		player_action_type	action
	)

{
    bool continuous = false;
    switch(action)
    {
        case PLAYER_ACT_SIT:
        case PLAYER_ACT_STAND:
        {
            get_session()->player()->on_action_request(action);
            break;
        }
        case PLAYER_ACT_ATTACK_REPEAT:
        {
            continuous = true;
        }
        case PLAYER_ACT_ATTACK:
        {
            std::shared_ptr<Unit> target = get_session()->player()->get_nearby_unit(target_guid);
            
            if (target == nullptr)
            {
                HLog(error) << "Target not found.";
                return;
            }
            CombatRegistry::MeleeExecutionOperation::MeleeExecutionOperand::s_melee_execution_operation_config config;
            config.continuous = continuous;
            CombatRegistry::MeleeExecutionOperation::MeleeExecutionOperand *operand = new CombatRegistry::MeleeExecutionOperation::MeleeExecutionOperand(get_session()->player(), target, config);
            CombatRegistry::MeleeExecutionOperation *operation = new CombatRegistry::MeleeExecutionOperation(operand, CombatRegistry::MeleeExecutionOperation::melee_execution_operation_type::MELEE_EXECUTION_OPERATION_TARGET);
 
            int time = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
            
            CombatRegistry::CombatStage *stage = get_session()->player()->combat_registry()->create_combat_stage(time);
            
            stage->add_operation(operation);
 
            get_session()->player()->combat_registry()->queue_combat_stage(stage);
        }
        default:
            break;
    };
    
}

References Horizon::Zone::CombatRegistry::CombatStage::add_operation(), Horizon::Zone::CombatRegistry::MeleeExecutionOperation::MeleeExecutionOperand::s_melee_execution_operation_config::continuous, Horizon::ClientInterface< ZoneSession >::get_session(), HLog, PLAYER_ACT_ATTACK, PLAYER_ACT_ATTACK_REPEAT, PLAYER_ACT_SIT, and PLAYER_ACT_STAND.

Here is the call graph for this function:

◆ adjust_manner_by_name()

void ZoneClientInterface::adjust_manner_by_name ( std::string name )

{
 
}

◆ auction()

UI::Auction & Horizon::Zone::ZoneClientInterface::auction ( )

inline

67{ return _auction; }

References _auction.

◆ auto_revive()

void ZoneClientInterface::auto_revive ( )

{
    
}

◆ bargain_sale_tool_close()

void ZoneClientInterface::bargain_sale_tool_close ( )

{
 
}

◆ blocking_play_cancel()

void ZoneClientInterface::blocking_play_cancel ( )

{
    ZC_ALT_PING pkt(get_session());
    pkt.deliver();
    // TODO: should also send ZC_SPECIALPOPUP for clients >= 20221005 based on mapflag.
}

References Horizon::Zone::ZC_ALT_PING::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ broadcast()

void ZoneClientInterface::broadcast ( std::string message )

{
 
}

◆ broadcast_local()

void ZoneClientInterface::broadcast_local ( std::string message )

{
 
}

◆ cash_point_purchase()

void ZoneClientInterface::cash_point_purchase	(	int	kafra_points,
		std::vector< cz_pc_buy_cash_point_item >	items
	)

Cash Point Store.

{
 
}

◆ change_cart()

void ZoneClientInterface::change_cart ( int16_t num )

{
 
}

◆ change_direction()

void ZoneClientInterface::change_direction	(	int	head_direction,
		int	body_direction
	)

{
 
}

◆ change_effect_state()

void ZoneClientInterface::change_effect_state ( int effect_state )

{
 
}

◆ change_map_type()

void ZoneClientInterface::change_map_type	(	int	x,
		int	y,
		bool	walkable
	)

{
 
}

◆ chatroom()

UI::Chatroom & Horizon::Zone::ZoneClientInterface::chatroom ( )

inline

60{ return _chat_room; }

References _chat_room.

◆ check_status()

void ZoneClientInterface::check_status ( std::string name )

{
 
}

◆ clan()

UI::Clan & Horizon::Zone::ZoneClientInterface::clan ( )

inline

69{ return _clan; }

References _clan.

◆ client_version()

void ZoneClientInterface::client_version ( int version )

{
 
}

◆ close_buying_store()

void ZoneClientInterface::close_buying_store ( )

{
    
}

◆ close_vending()

void ZoneClientInterface::close_vending ( )

{
    
}

◆ command_mercenary()

void ZoneClientInterface::command_mercenary	(	int	type,
		cz_command_mercenary_command_type	command
	)

Pet.

{
 
}

◆ command_pet()

void ZoneClientInterface::command_pet ( cz_command_pet_type command )

{
 
}

◆ create()

void ZoneClientInterface::create ( std::string create )

{
 
}

◆ create_viewport_entry()

unit_viewport_entry ZoneClientInterface::create_viewport_entry ( std::shared_ptr< Unit > unit )

{
    unit_viewport_entry entry;
 
    if (unit == nullptr)
        return entry;
    
    std::shared_ptr<Horizon::Zone::Traits::Status> status = unit->status();
 
    if (status == nullptr)
        return entry;
 
    entry._guid = unit->guid();
    entry._unit_type = unit->type();
    entry.speed = status->movement_speed()->total();
    entry.body_state = 0;
    entry.health_state = 0;
    entry.effect_state = 0;
    entry.job_id = unit->job_id();
    entry.hair_style_id = status->hair_style()->get();
    entry.hair_color_id = status->hair_color()->get();
    entry.robe_id = status->robe_sprite()->get();
    entry.guild_id = 0;
    entry.guild_emblem_version = 0;
    entry.honor = unit->type() == UNIT_PLAYER ? status->honor()->total() : 0;
    entry.virtue = unit->type() == UNIT_PLAYER ? status->virtue()->total() : 0;
    entry.in_pk_mode = 0;
    entry.current_x = unit->map_coords().x();
    entry.current_y = unit->map_coords().y();
    entry.current_dir = unit->direction();
    
    if (unit->is_walking()) {
        entry.to_x = unit->dest_coords().x();
        entry.to_y = unit->dest_coords().y();
    }
    
    entry.posture = unit->posture();
    entry.base_level = status->base_level()->total();
    entry.font = 1;
 
    if (status->current_hp()->total() < status->max_hp()->total()) {
        entry.max_hp = status->max_hp()->total();
        entry.hp = status->current_hp()->total();
    }
    else {
        entry.max_hp = -1;
        entry.hp = -1;
    }
    
    entry.is_boss = 0;
    entry.body_style_id = 0;
    std::strncpy(entry.name, unit->name().c_str(), unit->name().size());
    
    switch (entry._unit_type)
    {
        case UNIT_PLAYER:
            entry.character_id = unit->downcast<Horizon::Zone::Units::Player>()->character()._character_id;
            entry.x_size = entry.y_size = 0;
            entry.gender = unit->downcast<Horizon::Zone::Units::Player>()->character()._gender;
            break;
        case UNIT_NPC:
        default:
            entry.x_size = entry.y_size = 0;
            break;
    }
    
    return entry;
}

◆ create_viewport_item_entry()

item_viewport_entry ZoneClientInterface::create_viewport_item_entry ( std::shared_ptr< Units::Item > item )

{
    item_viewport_entry entry;
 
    if (item == nullptr)
        return entry;
    
    entry._guid = item->guid();
    entry.item_id = item->config()->item_id;
    entry.x = item->map_coords().x();
    entry.y = item->map_coords().y();
    entry.amount = item->amount();
    entry.is_identified = item->is_identified();
    entry.x_area = item->x_area();
    entry.y_area = item->y_area();
 
    return entry;
}

References viewport_entry::_guid, item_viewport_entry::amount, item_viewport_entry::is_identified, item_viewport_entry::item_id, item_viewport_entry::x, item_viewport_entry::x_area, item_viewport_entry::y, and item_viewport_entry::y_area.

◆ disconnect()

bool ZoneClientInterface::disconnect ( int8_t type )

{
    std::shared_ptr<Horizon::Zone::SCENARIO_GENERIC_TASK> s_task = std::make_shared<Horizon::Zone::SCENARIO_GENERIC_TASK>(sZone->get_component_of_type<Horizon::Zone::ZoneRuntime>(Horizon::System::RUNTIME_RUNTIME)->get_system_routine_manager());
    std::shared_ptr<Horizon::Zone::SCENARIO_GENERIC_TASK::GenericTask> w_task = std::make_shared<Horizon::Zone::SCENARIO_GENERIC_TASK::GenericTask>(s_task);
    s_task->get_runtime_synchronization_mutex().lock();
    s_task->set_session(get_session());
    w_task->set_task([type](std::shared_ptr<Horizon::Zone::SCENARIO_GENERIC_TASK::GenericTask> task) {
        std::shared_ptr<ZoneSession> session = std::dynamic_pointer_cast<Horizon::Zone::ActiveRuntimeScenario>(task->get_runtime_context())->get_session();
        ZC_ACK_REQ_DISCONNECT rpkt(session);
        rpkt.deliver(type);
    });
    s_task->get_runtime_synchronization_mutex().unlock();
    s_task->push(w_task);
    sZone->get_component_of_type<Horizon::Zone::ZoneRuntime>(Horizon::System::RUNTIME_RUNTIME)->get_system_routine_manager().push(s_task);
 
    //sZone->get_component_of_type<GameLogicProcess>(Horizon::System::RUNTIME_GAMELOGIC)->get_map_process().manage_session_in_map(SESSION_ACTION_LOGOUT_AND_REMOVE, get_session()->get_map_name(), get_session());
    return true;
}

References Horizon::Zone::ZC_ACK_REQ_DISCONNECT::deliver(), Horizon::ClientInterface< ZoneSession >::get_session(), KernelComponent::get_system_routine_manager(), Horizon::System::RUNTIME_RUNTIME, and sZone.

Here is the call graph for this function:

◆ disconnect_account()

void ZoneClientInterface::disconnect_account ( int account_id )

{
 
}

◆ disconnect_all_players()

void ZoneClientInterface::disconnect_all_players ( )

Administration.

{
 
}

◆ display_item_card_composition()

void ZoneClientInterface::display_item_card_composition	(	int	card_index,
		int	equip_index = `0`
	)

{
 
}

◆ emotion()

void ZoneClientInterface::emotion ( int type )

Misc.

{
 
}

◆ equip_item()

void ZoneClientInterface::equip_item	(	int16_t	inventory_index,
		int16_t	equip_location_mask
	)

{
    get_session()->player()->inventory()->equip_item(inventory_index, equip_location_mask);
}

References Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ friend_()

UI::Friend & Horizon::Zone::ZoneClientInterface::friend_ ( )

inline

65{ return _friend; }

References _friend.

◆ get_npc_contact_guid()

uint32_t Horizon::Zone::ZoneClientInterface::get_npc_contact_guid ( )

inline

128{ return _npc_contact_guid; }

Horizon::Zone::ZoneClientInterface::_npc_contact_guid

uint32_t _npc_contact_guid

Definition: ZoneClientInterface.hpp:358

References _npc_contact_guid.

◆ give_manner_point()

void ZoneClientInterface::give_manner_point	(	int	account_id,
		cz_req_give_manner_point_type	type,
		int	value
	)

{
 
}

◆ guild()

UI::Guild & Horizon::Zone::ZoneClientInterface::guild ( )

inline

64{ return _guild; }

References _guild.

◆ identify_item()

void ZoneClientInterface::identify_item ( int inventory_index )

{
    
}

◆ ignore_list()

void ZoneClientInterface::ignore_list ( )

{
    
}

◆ increase_status_point()

bool ZoneClientInterface::increase_status_point	(	status_point_type	type,
		uint8_t	amount
	)

{
    std::shared_ptr<Horizon::Zone::Units::Player> pl = get_session()->player();
 
    if (pl == nullptr)
        return false;
 
    pl->status()->increase_status_point(type, amount);
    return true;
}

References Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ invite_baby()

void ZoneClientInterface::invite_baby ( int account_id )

{
 
}

◆ login()

bool ZoneClientInterface::login	(	uint32_t	account_id,
		uint32_t	char_id,
		uint32_t	auth_code,
		uint32_t	client_time,
		uint8_t	gender
	)

{   
    std::shared_ptr<Horizon::System::RuntimeContextChain> chain = std::make_shared<Horizon::System::RuntimeContextChain>(Horizon::System::RUNTIME_RUNTIME);
    std::shared_ptr<Horizon::Zone::SCENARIO_LOGIN> s_login = std::make_shared<Horizon::Zone::SCENARIO_LOGIN>(sZone->get_component_of_type<Horizon::Zone::ZoneRuntime>(Horizon::System::RUNTIME_RUNTIME)->get_system_routine_manager());
    std::shared_ptr<Horizon::Zone::SCENARIO_LOGIN::Login> w_login = std::make_shared<Horizon::Zone::SCENARIO_LOGIN::Login>(s_login);
 
    Horizon::Zone::s_scenario_login_request w_l_request;
    w_l_request.account_id = account_id;
    w_l_request.char_id = char_id;
    w_l_request.auth_code = auth_code;
    w_l_request.client_time = client_time;
    w_l_request.gender = gender;
 
    s_login->get_runtime_synchronization_mutex().lock();
    s_login->set_session(get_session());
    w_login->set_request(w_l_request);
    s_login->get_runtime_synchronization_mutex().unlock();
    s_login->push(w_login);
 
    chain->push(s_login);
 
    sZone->get_component_of_type<Horizon::Zone::ZoneRuntime>(Horizon::System::RUNTIME_RUNTIME)->get_resource_manager().add<RESOURCE_PRIORITY_PRIMARY>(get_session()->get_session_id(), get_session());
 
    sZone->get_component_of_type<Horizon::Zone::ZoneRuntime>(Horizon::System::RUNTIME_RUNTIME)->get_system_routine_manager().push(chain);
 
    while(s_login->get_context_result() == Horizon::System::RUNTIME_CONTEXT_NO_STATE)
    {
        std::this_thread::sleep_for(std::chrono::microseconds(100));
    }
 
    if (s_login->get_context_result() == Horizon::System::RUNTIME_CONTEXT_FAIL) {
        ZC_ACK_REQ_DISCONNECT pkt(get_session());
        pkt.deliver(0);
        return false;
    }
 
    std::shared_ptr<Horizon::System::RuntimeContextChain> chain_2 = std::make_shared<Horizon::System::RuntimeContextChain>(Horizon::System::RUNTIME_RUNTIME);
 
    std::shared_ptr<Horizon::Zone::SCENARIO_CREATE_PLAYER> s_create_player;
    s_create_player = std::make_shared<Horizon::Zone::SCENARIO_CREATE_PLAYER>(sZone->get_component_of_type<Horizon::Zone::GameLogicProcess>(Horizon::System::RUNTIME_GAMELOGIC, 1)->get_system_routine_manager());
 
    std::shared_ptr<Horizon::Zone::SCENARIO_CREATE_PLAYER::CreatePlayer> w_create_player = std::make_shared<Horizon::Zone::SCENARIO_CREATE_PLAYER::CreatePlayer>(s_create_player);
    s_create_player->get_runtime_synchronization_mutex().lock();
    w_create_player->set_request(Horizon::Zone::s_player_loaded_data{(int32_t)account_id});
    s_create_player->set_previous_context_result(s_login->get_result());
    s_create_player->set_session(get_session());
    s_create_player->get_runtime_synchronization_mutex().unlock();
    s_create_player->push(w_create_player);
 
    std::shared_ptr<Horizon::Zone::SCENARIO_LOGIN_RESPONSE> s_login_response;
    s_login_response = std::make_shared<Horizon::Zone::SCENARIO_LOGIN_RESPONSE>(sZone->get_component_of_type<Horizon::Zone::ZoneRuntime>(Horizon::System::RUNTIME_RUNTIME)->get_system_routine_manager());
    s_login_response->get_runtime_synchronization_mutex().lock();
    s_login_response->set_session(get_session());
    s_login_response->get_runtime_synchronization_mutex().unlock();
 
    std::shared_ptr<Horizon::Zone::SCENARIO_LOGIN_RESPONSE::LoginResponse> w_login_response = std::make_shared<Horizon::Zone::SCENARIO_LOGIN_RESPONSE::LoginResponse>(s_login_response);
    Horizon::Zone::SCENARIO_LOGIN_RESPONSE::s_scenario_login_response_request w_l_r_request;
 
    w_l_r_request.account_id = account_id;
    w_l_r_request.current_x = s_login->get_result().get_one().current_x;
    w_l_r_request.current_y = s_login->get_result().get_one().current_y;
    w_l_r_request.font = 1;
 
    w_login_response->set_request(w_l_r_request);
    s_login_response->push(w_login_response);
 
    chain_2->push(s_create_player);
    chain_2->push(s_login_response);
 
    sZone->get_component_of_type<Horizon::Zone::ZoneRuntime>(Horizon::System::RUNTIME_RUNTIME)->get_system_routine_manager().push(chain_2);
 
    while(s_login_response->get_context_result() == Horizon::System::RUNTIME_CONTEXT_NO_STATE) {
        std::this_thread::sleep_for(std::chrono::microseconds(100));
    }
 
    if (s_login_response->get_context_result() == Horizon::System::RUNTIME_CONTEXT_FAIL) {
        ZC_ACK_REQ_DISCONNECT pkt(get_session());
        pkt.deliver(0);
        return false;
    }
 
    std::shared_ptr<Horizon::Zone::SCENARIO_GENERIC_TASK> s_task = std::make_shared<Horizon::Zone::SCENARIO_GENERIC_TASK>(sZone->get_component_of_type<Horizon::Zone::GameLogicProcess>(Horizon::System::RUNTIME_GAMELOGIC)->get_system_routine_manager());
    std::shared_ptr<Horizon::Zone::SCENARIO_GENERIC_TASK::GenericTask> w_task = std::make_shared<Horizon::Zone::SCENARIO_GENERIC_TASK::GenericTask>(s_task);
    s_task->get_runtime_synchronization_mutex().lock();
    s_task->set_session(get_session());
    w_task->set_task([](std::shared_ptr<Horizon::Zone::SCENARIO_GENERIC_TASK::GenericTask> task) {
        std::shared_ptr<ZoneSession> session = std::dynamic_pointer_cast<Horizon::Zone::ActiveRuntimeScenario>(task->get_runtime_context())->get_session();
        session->player()->initialize();
    });
    s_task->get_runtime_synchronization_mutex().unlock();
    s_task->push(w_task);
    sZone->get_component_of_type<Horizon::Zone::GameLogicProcess>(Horizon::System::RUNTIME_GAMELOGIC)->get_system_routine_manager().push(s_task);
 
    return true;
}

References Horizon::Zone::ZC_ACK_REQ_DISCONNECT::deliver(), Horizon::ClientInterface< ZoneSession >::get_session(), KernelComponent::get_system_routine_manager(), RESOURCE_PRIORITY_PRIMARY, Horizon::System::RUNTIME_CONTEXT_FAIL, Horizon::System::RUNTIME_CONTEXT_NO_STATE, Horizon::System::RUNTIME_GAMELOGIC, Horizon::System::RUNTIME_RUNTIME, and sZone.

Here is the call graph for this function:

◆ mail()

UI::Mail & Horizon::Zone::ZoneClientInterface::mail ( )

inline

68{ return _mail; }

References _mail.

◆ make_arrow()

void ZoneClientInterface::make_arrow ( int16_t item_id )

{
 
}

◆ make_item()

void ZoneClientInterface::make_item	(	cz_req_makingitem_type	type,
		int16_t	item_id
	)

{
 
}

◆ map_enter()

void ZoneClientInterface::map_enter ( )

{
    get_session()->player()->on_map_enter();
}

References Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ memorial_dungeon_command()

void ZoneClientInterface::memorial_dungeon_command ( cz_memorial_dungeon_command_type command )

Instancing.

{
 
}

◆ message()

void ZoneClientInterface::message ( std::string message )

Battlegrounds.

Battleground.

{
 
}

Referenced by notify_chat(), parse_chat_message(), and whisper_message().

Here is the caller graph for this function:

◆ move_homunculus_to_coordinates()

void ZoneClientInterface::move_homunculus_to_coordinates	(	int	guid,
		int	x,
		int	y,
		int	dir
	)

{
 
}

◆ move_homunculus_to_master()

void ZoneClientInterface::move_homunculus_to_master ( int guid )

{
    
}

◆ move_item_from_cart_to_inventory()

void ZoneClientInterface::move_item_from_cart_to_inventory	(	int16_t	inventory_index,
		int	amount
	)

{
 
}

◆ move_item_from_cart_to_storage()

void ZoneClientInterface::move_item_from_cart_to_storage	(	int16_t	inventory_index,
		int	amount
	)

{
 
}

◆ move_item_from_inventory_to_cart()

void ZoneClientInterface::move_item_from_inventory_to_cart	(	int16_t	inventory_index,
		int	amount
	)

{
 
}

◆ move_item_from_inventory_to_storage()

void ZoneClientInterface::move_item_from_inventory_to_storage	(	int16_t	inventory_index,
		int	amount
	)

{
    int32_t current_storage_id = get_session()->player()->get_current_storage_id();
    std::shared_ptr<Assets::Storage> storage = get_session()->player()->get_storage(current_storage_id);
    storage->add_item_from_inventory(inventory_index, amount);
}

References Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ move_item_from_storage_to_cart()

void ZoneClientInterface::move_item_from_storage_to_cart	(	int16_t	inventory_index,
		int	amount
	)

{
 
}

◆ move_item_from_storage_to_inventory()

void ZoneClientInterface::move_item_from_storage_to_inventory	(	int16_t	storage_index,
		int	amount
	)

{
    int32_t current_storage_id = get_session()->player()->get_current_storage_id();
    std::shared_ptr<Assets::Storage> storage = get_session()->player()->get_storage(current_storage_id);
    storage->add_item_to_inventory(storage_index, amount);
}

References Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ move_to_map()

void ZoneClientInterface::move_to_map	(	std::string	map_name,
		int16_t	x,
		int16_t	y
	)

{
 
}

◆ notify_action() [1/2]

bool ZoneClientInterface::notify_action	(	int32_t	target_guid,
		player_action_type	action
	)

{
    ZC_NOTIFY_ACT na(get_session());
    na.deliver(guid, (int8_t) action);
    return true;
}

References Horizon::Zone::ZC_NOTIFY_ACT::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_action() [2/2]

bool ZoneClientInterface::notify_action ( player_action_type action )

{
    ZC_NOTIFY_ACT na(get_session());
    na.deliver((int8_t) action);
    return true;
}

References Horizon::Zone::ZC_NOTIFY_ACT::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_action_failure()

bool ZoneClientInterface::notify_action_failure ( int16_t message_type )

{
    ZC_ACTION_FAILURE pkt(get_session());
    pkt.deliver(message_type);
    return true;
}

References Horizon::Zone::ZC_ACTION_FAILURE::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_appearance_update()

bool ZoneClientInterface::notify_appearance_update	(	unit_appearance_type	type,
		int32_t	value,
		int32_t	value2
	)

{
    ZC_SPRITE_CHANGE2 pkt(get_session());
    pkt.deliver(get_session()->player()->guid(), type, value, value2);
    return true;
}

References Horizon::Zone::ZC_SPRITE_CHANGE2::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_attack_range_update()

bool ZoneClientInterface::notify_attack_range_update ( int32_t value )

{
    ZC_ATTACK_RANGE pkt(get_session());
    pkt.deliver(value);
    return true;
 
}

References Horizon::Zone::ZC_ATTACK_RANGE::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_attribute_update()

bool ZoneClientInterface::notify_attribute_update	(	status_point_type	type,
		int32_t	value,
		int32_t	value2
	)

{
    ZC_COUPLESTATUS pkt(get_session());
    pkt.deliver(type, value, value2);
    return true;
}

References Horizon::Zone::ZC_COUPLESTATUS::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_bind_on_equip()

bool ZoneClientInterface::notify_bind_on_equip ( int16_t inventory_index )

{
    ZC_NOTIFY_BIND_ON_EQUIP pkt(get_session());
    pkt.deliver(inventory_index);
    return true;
}

References Horizon::Zone::ZC_NOTIFY_BIND_ON_EQUIP::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_buying_store_itemlist()

bool ZoneClientInterface::notify_buying_store_itemlist	(	int	account_id,
		int	store_id,
		int	zeny_limit,
		std::vector< zc_ack_itemlist_buying_store >	items
	)

{
    ZC_ACK_ITEMLIST_BUYING_STORE pkt(get_session());
    pkt.deliver(account_id, store_id, zeny_limit, items);
    return true;
}

References Horizon::Zone::ZC_ACK_ITEMLIST_BUYING_STORE::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_cart_weight_update()

bool ZoneClientInterface::notify_cart_weight_update ( )

{
    ZC_NOTIFY_CARTITEM_COUNTINFO pkt(get_session());
    //pkt.deliver(get_session()->player()->cart()->get_item_count(), MAX_CART_ITEMS, get_session()->player()->cart()->weight(), get_session()->player()->cart()->max_weight());
    return true;
}

References Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_chat()

bool ZoneClientInterface::notify_chat ( std::string message )

Chat.

{
    ZC_NOTIFY_PLAYERCHAT pkt(get_session());
    pkt.deliver(message);
    return true;
}

References Horizon::Zone::ZC_NOTIFY_PLAYERCHAT::deliver(), Horizon::ClientInterface< ZoneSession >::get_session(), and message().

Referenced by parse_chat_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ notify_compound_attribute_update()

bool ZoneClientInterface::notify_compound_attribute_update	(	status_point_type	type,
		int32_t	value
	)

{
    ZC_PAR_CHANGE pkt(get_session());
    pkt.deliver(type, value);
    return true;
}

References Horizon::Zone::ZC_PAR_CHANGE::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_damage()

bool ZoneClientInterface::notify_damage	(	int	guid,
		int	target_guid,
		int	start_time,
		int	delay_skill,
		int	delay_damage,
		int	damage,
		bool	is_sp_damaged,
		int	number_of_hits,
		int8_t	action_type,
		int	left_damage
	)

Combat.

{
    ZC_NOTIFY_ACT3 pkt(get_session());
    pkt.deliver(guid, target_guid, start_time, delay_skill, delay_damage, damage, is_sp_damaged, number_of_hits, action_type, left_damage);
    return true;
}

References Horizon::Zone::ZC_NOTIFY_ACT3::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_delete_item()

bool ZoneClientInterface::notify_delete_item	(	int16_t	inventory_index,
		int16_t	amount,
		item_deletion_reason_type	reason
	)

{
    ZC_DELETE_ITEM_FROM_BODY pkt(get_session());
    pkt.deliver(inventory_index, amount, reason);
    return true;
}

References Horizon::Zone::ZC_DELETE_ITEM_FROM_BODY::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_equip_arrow()

bool ZoneClientInterface::notify_equip_arrow ( std::shared_ptr< const item_entry_data > item )

{
    ZC_EQUIP_ARROW pkt(get_session());
    pkt.deliver(item->index.inventory);
    return true;
}

References Horizon::Zone::ZC_EQUIP_ARROW::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_equip_item()

bool ZoneClientInterface::notify_equip_item	(	std::shared_ptr< const item_entry_data >	item,
		item_equip_result_type	result
	)

{
    ZC_ACK_WEAR_EQUIP_V5 pkt(get_session());
    pkt.deliver(item->index.inventory, item->current_equip_location_mask, item->sprite_id, result);
    return true;
}

References Horizon::Zone::ZC_ACK_WEAR_EQUIP_V5::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_equipment_item_list()

bool ZoneClientInterface::notify_equipment_item_list ( std::vector< std::shared_ptr< const item_entry_data > > const & items )

{
#if (CLIENT_TYPE == 'R' && PACKET_VERSION >= 20180829) || \
    (CLIENT_TYPE == 'Z' && PACKET_VERSION >= 20180919) || \
    (CLIENT_TYPE == 'M' && PACKET_VERSION >= 20181002)
    ZC_STORE_ITEMLIST_EQUIP_V6 pkt(get_session());
    pkt.deliver(INVTYPE_INVENTORY, items);
#else
    ZC_INVENTORY_ITEMLIST_EQUIP_V6 pkt(get_session());
    pkt.deliver(items);
#endif
    return true;
}

References Horizon::Zone::ZC_STORE_ITEMLIST_EQUIP_V6::deliver(), Horizon::ClientInterface< ZoneSession >::get_session(), and INVTYPE_INVENTORY.

Here is the call graph for this function:

◆ notify_experience_update()

bool ZoneClientInterface::notify_experience_update	(	status_point_type	type,
		int32_t	value
	)

{
 
#if CLIENT_TYPE == 'Z' || \
    (CLIENT_TYPE == 'M' && PACKET_VERSION >= 20170906) || \
    (CLIENT_TYPE == 'R' && PACKET_VERSION >= 20170830)
    ZC_LONGLONGPAR_CHANGE pkt(get_session());
#else
    ZC_LONGPAR_CHANGE pkt(get_session());
#endif
    pkt.deliver(type, value);
    return true;
}

References Horizon::Zone::ZC_LONGLONGPAR_CHANGE::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_give_manner_point()

bool ZoneClientInterface::notify_give_manner_point ( zc_ack_give_manner_point_result_type result )

{
    ZC_ACK_GIVE_MANNER_POINT pkt(get_session());
    pkt.deliver(result);
    return true;
}

References Horizon::Zone::ZC_ACK_GIVE_MANNER_POINT::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_hostile_skill_use()

void ZoneClientInterface::notify_hostile_skill_use	(	int16_t	skill_id,
		int32_t	src_guid,
		int32_t	target_guid,
		int32_t	start_time,
		int32_t	attack_motion,
		int32_t	delay_motion,
		int32_t	damage,
		int16_t	level,
		int16_t	count,
		int8_t	action
	)

{
    ZC_NOTIFY_SKILL2 pkt(get_session());
 
    pkt._skill_id = skill_id;
    pkt._source_id = src_guid;
    pkt._start_time = start_time;
    pkt._target_id = target_guid;
    pkt._level = level;
    pkt._attack_motion = attack_motion;
    pkt._attacked_motion = delay_motion;
    pkt._damage = damage;
    pkt._count = number_of_hits;
    pkt._action = action;
    
    get_session()->player()->notify_in_area(pkt.serialize(), GRID_NOTIFY_AREA);
}

Here is the call graph for this function:

◆ notify_identified_item()

bool ZoneClientInterface::notify_identified_item	(	int16_t	inventory_index,
		zc_ack_item_identify_result_type	result
	)

{
    ZC_ACK_ITEMIDENTIFY pkt(get_session());
    pkt.deliver(inventory_index, result);
    return true;
}

References Horizon::Zone::ZC_ACK_ITEMIDENTIFY::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_initial_status()

bool ZoneClientInterface::notify_initial_status ( )

Status.

{
    if (get_session()->player() == nullptr)
        return false;
 
    std::shared_ptr<Horizon::Zone::Traits::Status> status = get_session()->player()->status();
 
    if (status == nullptr)
        return false;
 
    ZC_STATUS zcs(get_session());
    zc_status_data data;
    
    data.status_points = status->status_point()->get_base();
    data.strength = status->strength()->get_base();
    data.strength_req_stats = status->strength_cost()->get_base();
    data.agility = status->agility()->get_base();
    data.agility_req_stats = status->agility_cost()->get_base();
    data.vitality = status->vitality()->get_base();
    data.vitality_req_stats = status->vitality_cost()->get_base();
    data.intelligence = status->intelligence()->get_base();
    data.intelligence_req_stats = status->intelligence_cost()->get_base();
    data.dexterity = status->dexterity()->get_base();
    data.dexterity_req_stats = status->dexterity_cost()->get_base();
    data.luck = status->luck()->get_base();
    data.luck_req_stats = status->luck_cost()->get_base();
    data.status_atk = status->status_atk()->total();
    data.equip_atk = status->equip_atk()->total();
    data.status_matk = status->status_matk()->total();
    data.equip_matk = 0;
    data.soft_def = status->soft_def()->total();
    data.hard_def = 0;
    data.soft_mdef = status->soft_mdef()->total();
    data.hard_mdef = 0;
    data.hit = status->hit()->total();
    data.flee = status->flee()->total();
    data.perfect_dodge = 0;
    data.critical = status->crit()->total() / 10;
    data.attack_speed = status->attack_speed()->total();
    data.plus_aspd = 0;
    
    zcs.deliver(data);
 
    return true;
}

Here is the call graph for this function:

◆ notify_inventory_end()

bool ZoneClientInterface::notify_inventory_end ( inventory_type type )

{
#if (CLIENT_TYPE == 'R' && PACKET_VERSION >= 20180829) || \
    (CLIENT_TYPE == 'Z' && PACKET_VERSION >= 20180919) || \
    (CLIENT_TYPE == 'M' && PACKET_VERSION >= 20181002)
    ZC_INVENTORY_END pkt(get_session());
    pkt.deliver(type);
#endif
    return true;
}

References Horizon::Zone::ZC_INVENTORY_END::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_inventory_move_failed()

bool ZoneClientInterface::notify_inventory_move_failed	(	int16_t	inventory_index,
		bool	silent
	)

{
    ZC_INVENTORY_MOVE_FAILED pkt(get_session());
    pkt.deliver(inventory_index, silent);
    return true;
}

References Horizon::Zone::ZC_INVENTORY_MOVE_FAILED::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_inventory_start()

bool ZoneClientInterface::notify_inventory_start	(	inventory_type	type,
		std::string	name
	)

Inventory Start / End.

{
#if (CLIENT_TYPE == 'R' && PACKET_VERSION >= 20180829) || \
    (CLIENT_TYPE == 'Z' && PACKET_VERSION >= 20180919) || \
    (CLIENT_TYPE == 'M' && PACKET_VERSION >= 20181002)
    ZC_INVENTORY_START pkt(get_session());
    pkt.deliver(type, name);
#endif
    return true;
}

References Horizon::Zone::ZC_INVENTORY_START::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_item_composition()

bool ZoneClientInterface::notify_item_composition	(	int16_t	item_inventory_index,
		int16_t	card_inventory_index,
		zc_ack_item_composition_result_type	result
	)

{
    ZC_ACK_ITEMCOMPOSITION pkt(get_session());
    pkt.deliver(item_inventory_index, card_inventory_index, result);
    return true;
}

References Horizon::Zone::ZC_ACK_ITEMCOMPOSITION::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_item_drop()

bool ZoneClientInterface::notify_item_drop	(	int	guid,
		int	item_id,
		int	type,
		int	identified,
		int	x,
		int	y,
		int	x_area,
		int	y_area,
		int	amount,
		int	show_drop_effect = `0`,
		int	drop_effect_mode = `0`
	)

{
    ZC_ITEM_FALL_ENTRY pkt(get_session());
    pkt.deliver(guid, item_id, type, identified, x, y, x_area, y_area, amount, show_drop_effect, drop_effect_mode);
    return true;
}

References Horizon::Zone::ZC_ITEM_FALL_ENTRY::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_item_merge()

bool ZoneClientInterface::notify_item_merge	(	int	inventory_index,
		int	amount,
		zc_ack_merge_item_reason_type	reason
	)

{
    ZC_ACK_MERGE_ITEM pkt(get_session());
    pkt.deliver(inventory_index, amount, reason);
    return true;
}

References Horizon::Zone::ZC_ACK_MERGE_ITEM::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_item_refining()

bool ZoneClientInterface::notify_item_refining	(	zc_ack_itemrefining_result_type	result,
		int16_t	inventory_index,
		int16_t	refine_lv
	)

{
    ZC_ACK_ITEMREFINING pkt(get_session());
    pkt.deliver(result, inventory_index, refine_lv);
    return true;
}

References Horizon::Zone::ZC_ACK_ITEMREFINING::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_item_removal_from_floor()

bool ZoneClientInterface::notify_item_removal_from_floor ( int guid )

{
    ZC_ITEM_DISAPPEAR pkt(get_session());
    pkt.deliver(guid);
    return true;
}

References Horizon::Zone::ZC_ITEM_DISAPPEAR::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_item_repair()

bool ZoneClientInterface::notify_item_repair	(	int	inventory_index,
		zc_ack_itemrepair_result_type	result
	)

{
    ZC_ACK_ITEMREPAIR pkt(get_session());
    pkt.deliver(inventory_index, result);
    return true;
}

References Horizon::Zone::ZC_ACK_ITEMREPAIR::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_learnt_skill_list()

bool ZoneClientInterface::notify_learnt_skill_list ( )

{
    const std::map<uint16_t, std::shared_ptr<skill_learnt_info>> &learnt_skills = get_session()->player()->get_learnt_skills();
    std::vector<zc_skill_info_data> sidv;
 
    for (auto sp : learnt_skills) {
        const std::shared_ptr<skill_learnt_info> ls = sp.second;
 
        if (ls == nullptr) {
            HLog(error) << "Learnt skill was a nullptr.";
            continue;
        }
 
        zc_skill_info_data si;
 
        std::shared_ptr<const skill_config_data> skd = SkillDB->get_skill_by_id(ls->skill_id);
        
        if (skd == nullptr) {
            HLog(error) << "Tried to send data for unknown skill with ID " << ls->skill_id;
            continue;
        }
 
        si.skill_id = ls->skill_id;
        si.skill_type = skd->primary_type;
        si.level = ls->level;
 
        si.sp_cost = ls->level ? skd->sp_cost[ls->level] : 0;
        si.range = ls->level ? skd->use_range[ls->level] : 0;
        
#if (CLIENT_VERSION == 'R' && PACKET_VERSION >= 20190807) || \
    (CLIENT_VERSION == 'Z' && PACKET_VERSION >= 20190918)
        si.level2 = ls->level;
#else
        strncpy(si.name, skd->name.c_str(), MAX_SKILL_NAME_LENGTH);
#endif
 
        if (ls->learn_type == SKILL_LEARN_PERMANENT) {
            job_class_type job_id = (job_class_type) get_session()->player()->job_id();
            std::shared_ptr<const skill_tree_config> stc = SkillDB->get_skill_tree_skill_id_by_job_id(job_id, ls->skill_id);
 
            if (stc == nullptr) {
                HLog(error) << "Skill ID " << ls->skill_id << " not found for Job ID " << (int32_t) job_id << ".";
                continue;
            }
 
            si.upgradeable = (ls->level < stc->max_level) ? 1 : 0;
        }
 
        sidv.push_back(si);
    }
 
    ZC_SKILLINFO_LIST pkt(get_session());
    pkt.deliver(sidv);
 
    return true;
}

References Horizon::Zone::ZC_SKILLINFO_LIST::deliver(), Horizon::ClientInterface< ZoneSession >::get_session(), HLog, zc_skill_info_data::level, zc_skill_info_data::level2, MAX_SKILL_NAME_LENGTH, zc_skill_info_data::name, zc_skill_info_data::range, zc_skill_info_data::skill_id, SKILL_LEARN_PERMANENT, zc_skill_info_data::skill_type, SkillDB, zc_skill_info_data::sp_cost, and zc_skill_info_data::upgradeable.

Here is the call graph for this function:

◆ notify_map_properties()

bool ZoneClientInterface::notify_map_properties ( zc_map_properties properties )

{
    ZC_MAPPROPERTY_R2 pkt(get_session());
    pkt.deliver(p);
    return true;
}

References Horizon::Zone::ZC_MAPPROPERTY_R2::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_move_to_map()

bool ZoneClientInterface::notify_move_to_map	(	std::string	map_name,
		int16_t	x,
		int16_t	y
	)

Map.

{
    ZC_NPCACK_MAPMOVE pkt(get_session());
    pkt.deliver(map_name, x, y);
    return true;
}

References Horizon::Zone::ZC_NPCACK_MAPMOVE::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_movement_stop()

bool ZoneClientInterface::notify_movement_stop	(	int32_t	guid,
		int16_t	x,
		int16_t	y
	)

{
    ZC_STOPMOVE pkt(get_session());
    pkt.deliver(guid, x, y);
    return true;
}

References Horizon::Zone::ZC_STOPMOVE::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_normal_item_list()

bool ZoneClientInterface::notify_normal_item_list ( std::vector< std::shared_ptr< const item_entry_data > > const & items )

{
#if (CLIENT_TYPE == 'R' && PACKET_VERSION >= 20180829) || \
    (CLIENT_TYPE == 'Z' && PACKET_VERSION >= 20180919) || \
    (CLIENT_TYPE == 'M' && PACKET_VERSION >= 20181002)
    ZC_STORE_ITEMLIST_NORMAL_V6 pkt(get_session());
    pkt.deliver(INVTYPE_INVENTORY, items);
#else
    ZC_INVENTORY_ITEMLIST_NORMAL_V5 pkt(get_session());
    pkt.deliver(items);
#endif
    return true;
}

References Horizon::Zone::ZC_STORE_ITEMLIST_NORMAL_V6::deliver(), Horizon::ClientInterface< ZoneSession >::get_session(), and INVTYPE_INVENTORY.

Here is the call graph for this function:

◆ notify_npc_close_dialog()

void ZoneClientInterface::notify_npc_close_dialog ( uint32_t npc_guid )

{
    ZC_CLOSE_DIALOG pkt(get_session());
    pkt.deliver(npc_guid);
}

References Horizon::Zone::ZC_CLOSE_DIALOG::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_npc_dialog()

void ZoneClientInterface::notify_npc_dialog	(	uint32_t	npc_guid,
		std::string	dialog
	)

{
    uint32_t current_npc_guid = get_session()->player()->npc_contact_guid();
    
}

References Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_npc_menu_list()

void ZoneClientInterface::notify_npc_menu_list	(	uint32_t	npc_guid,
		std::string const &	menu
	)

{
    ZC_MENU_LIST pkt(get_session());
    pkt.deliver(npc_guid, menu);
}

References Horizon::Zone::ZC_MENU_LIST::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_npc_next_dialog()

void ZoneClientInterface::notify_npc_next_dialog ( uint32_t npc_guid )

{
    ZC_WAIT_DIALOG pkt(get_session());
    pkt.deliver(npc_guid);
}

References Horizon::Zone::ZC_WAIT_DIALOG::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_open_vending()

bool ZoneClientInterface::notify_open_vending ( zc_ack_openstore2_result_type result )

{
    ZC_ACK_OPENSTORE2 pkt(get_session());
    pkt.deliver(result);
    return true;
}

References Horizon::Zone::ZC_ACK_OPENSTORE2::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_pickup_item()

bool ZoneClientInterface::notify_pickup_item	(	std::shared_ptr< item_entry_data >	item,
		int16_t	amount,
		item_inventory_addition_notif_type	result
	)

{
    ZC_ITEM_PICKUP_ACK_V7 pkt(get_session());
    pkt.deliver(*item, amount, result);
    return true;
}

References Horizon::Zone::ZC_ITEM_PICKUP_ACK_V7::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_player_movement()

bool ZoneClientInterface::notify_player_movement	(	int32_t	time,
		MapCoords	from,
		MapCoords	to
	)

{
    ZC_NOTIFY_PLAYERMOVE pkt(get_session());
    pkt.deliver(time, from.x(), from.y(), to.x(), to.y());
    return true;
}

References Horizon::Zone::ZC_NOTIFY_PLAYERMOVE::deliver(), Horizon::ClientInterface< ZoneSession >::get_session(), Coordinates< MAX_COORDINATES >::x(), and Coordinates< MAX_COORDINATES >::y().

Here is the call graph for this function:

◆ notify_pvp_points()

bool ZoneClientInterface::notify_pvp_points ( )

{
    //int char_id; int account_id; int win_point; int lose_point; int point;
    //ZC_ACK_PVPPOINT pkt(get_session());
    //pkt.deliver(char_id, account_id, win_point, lose_point, point);
    return true;
}

◆ notify_ranking()

bool ZoneClientInterface::notify_ranking	(	cz_req_ranking_type	type,
		std::vector< zc_ack_ranking_info >	info,
		int	ranking_points
	)

{
    ZC_ACK_RANKING pkt(get_session());
    pkt.deliver(type, info, ranking_points);
    return true;
}

References Horizon::Zone::ZC_ACK_RANKING::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_recovery()

bool ZoneClientInterface::notify_recovery	(	zc_notify_recovery_type	type,
		int	amount
	)

{
#if PACKET_VERSION < 20150513
    ZC_RECOVERY pkt(get_session());
#else 
    ZC_RECOVERY2 pkt(get_session());
#endif
    pkt.deliver(type, amount);
    return true;
}

References Horizon::Zone::ZC_RECOVERY::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_required_attribute_update()

bool ZoneClientInterface::notify_required_attribute_update	(	status_point_type	type,
		int32_t	value
	)

{
    ZC_STATUS_CHANGE pkt(get_session());
    pkt.deliver(type, value);
    return true;
}

References Horizon::Zone::ZC_STATUS_CHANGE::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_resurrection()

bool ZoneClientInterface::notify_resurrection	(	int32_t	guid,
		int	type
	)

{
    ZC_RESURRECTION pkt(get_session());
    pkt.deliver(guid, type);
    return true;
}

References Horizon::Zone::ZC_RESURRECTION::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_safe_skill_use()

void ZoneClientInterface::notify_safe_skill_use	(	int	skill_id,
		int	heal_amount,
		int	target_guid,
		zc_use_skill2_result_type	result
	)

{
    ZC_USE_SKILL2 pkt(get_session());
    pkt._skill_id = skill_id;
    pkt._heal_amount = heal_amount;
    pkt._target_guid = target_guid;
    pkt._result = (int) result;
    get_session()->player()->notify_in_area(pkt.serialize(), GRID_NOTIFY_AREA);
}

References Horizon::Zone::ZC_USE_SKILL2::_heal_amount, Horizon::Zone::ZC_USE_SKILL2::_result, Horizon::Zone::ZC_USE_SKILL2::_skill_id, Horizon::Zone::ZC_USE_SKILL2::_target_guid, Horizon::ClientInterface< ZoneSession >::get_session(), GRID_NOTIFY_AREA, and Horizon::Zone::ZC_USE_SKILL2::serialize().

Here is the call graph for this function:

◆ notify_skill_cast()

void ZoneClientInterface::notify_skill_cast	(	uint16_t	skill_id,
		uint32_t	src_guid,
		uint32_t	target_guid,
		uint16_t	target_x,
		uint16_t	target_y,
		uint32_t	element,
		int	cast_time
	)

{
#if (CLIENT_TYPE == 'R' && PACKET_VERSION >= 20190807) || \
    (CLIENT_TYPE == 'Z' && PACKET_VERSION >= 20190918)
    ZC_USESKILL_ACK3 pkt(get_session());
    pkt.deliver(skill_id, src_guid, target_guid, target_x, target_y, element, cast_time);
#elif (CLIENT_TYPE == 'M' && PACKET_VERSION >= 20090406) || \
    (CLIENT_TYPE == 'S' && PACKET_VERSION >= 20080618) || \
    (CLIENT_TYPE == 'R' && PACKET_VERSION >= 20080827)
    ZC_USESKILL_ACK pkt(get_session());
    pkt.deliver(src_guid, target_guid, target_x, target_y, skill_id, element, cast_time);
#endif
}

References Horizon::Zone::ZC_USESKILL_ACK3::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_skill_fail()

bool ZoneClientInterface::notify_skill_fail	(	int16_t	skill_id,
		int32_t	message_type,
		int32_t	item_id,
		skill_use_fail_cause_type	cause
	)

{
    ZC_ACK_TOUSESKILL pkt(get_session());
    pkt.deliver(skill_id, message_type, item_id, cause);
    return true;
}

References Horizon::Zone::ZC_ACK_TOUSESKILL::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_status_attribute_update()

bool ZoneClientInterface::notify_status_attribute_update	(	status_point_type	type,
		int32_t	value,
		bool	success
	)

{
    ZC_STATUS_CHANGE_ACK pkt(get_session());
    pkt.deliver(type, value, success);
    return true;
}

References Horizon::Zone::ZC_STATUS_CHANGE_ACK::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_status_change()

bool ZoneClientInterface::notify_status_change	(	int16_t	si_type,
		int32_t	guid,
		int8_t	state,
		int32_t	time_remaining,
		int32_t	val1,
		int32_t	val2,
		int32_t	val3
	)

{
    ZC_MSG_STATE_CHANGE2 sc(get_session());
 
    if (time_remaining < 0)
        time_remaining = 9999;
 
    sc.deliver(si_type, guid, state, time_remaining, val1, val2, val3);
    return true;
}

References Horizon::Zone::ZC_MSG_STATE_CHANGE2::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_status_change_end()

bool ZoneClientInterface::notify_status_change_end	(	int16_t	status_index,
		int32_t	guid,
		int8_t	state
	)

{
    ZC_MSG_STATE_CHANGE sce(get_session());
    sce.deliver(status_index, guid, state);
    return true;
}

References Horizon::Zone::ZC_MSG_STATE_CHANGE::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_storage_add_item()

bool ZoneClientInterface::notify_storage_add_item	(	std::shared_ptr< const item_entry_data >	entry,
		int	amount
	)

{
    ZC_ADD_ITEM_TO_STORE3 pkt(get_session());
    pkt.deliver(entry, amount);
    return true;
}

References Horizon::Zone::ZC_ADD_ITEM_TO_STORE3::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_storage_close()

bool ZoneClientInterface::notify_storage_close ( )

{
    ZC_CLOSE_STORE pkt(get_session());
    pkt.deliver();
    return true;
}

References Horizon::Zone::ZC_CLOSE_STORE::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Referenced by storage_close().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ notify_storage_equip_items()

bool ZoneClientInterface::notify_storage_equip_items	(	std::string	name,
		std::vector< std::shared_ptr< const item_entry_data > > const &	items
	)

{
    ZC_STORE_ITEMLIST_EQUIP_V6 pkt(get_session());
#if (PACKET_VERSION >= 20120925 && \
    ((CLIENT_TYPE == 'R' && PACKET_VERSION < 20180829) || \
    (CLIENT_TYPE == 'Z' && PACKET_VERSION < 20180919) || \
    (CLIENT_TYPE == 'M' && PACKET_VERSION < 20181002)))
    pkt.deliver(name, items);
#else
    pkt.deliver(INVTYPE_STORAGE, items);
#endif
    return true;
}

References Horizon::Zone::ZC_STORE_ITEMLIST_EQUIP_V6::deliver(), Horizon::ClientInterface< ZoneSession >::get_session(), and INVTYPE_STORAGE.

Here is the call graph for this function:

◆ notify_storage_normal_items()

bool ZoneClientInterface::notify_storage_normal_items	(	std::string	name,
		std::vector< std::shared_ptr< const item_entry_data > > const &	items
	)

{
#if (PACKET_VERSION >= 20120925 && \
    ((CLIENT_TYPE == 'R' && PACKET_VERSION < 20180829) || \
    (CLIENT_TYPE == 'Z' && PACKET_VERSION < 20180919) || \
    (CLIENT_TYPE == 'M' && PACKET_VERSION < 20181002)))
    ZC_STORE_ITEMLIST_NORMAL_V5 pkt(get_session());
    pkt.deliver(name, items);
#elif (CLIENT_TYPE == 'R' && PACKET_VERSION >= 20180829) || \
    (CLIENT_TYPE == 'Z' && PACKET_VERSION >= 20180919) || \
    (CLIENT_TYPE == 'M' && PACKET_VERSION >= 20181002)
    ZC_STORE_ITEMLIST_NORMAL_V6 pkt(get_session());
    pkt.deliver(INVTYPE_STORAGE, items);
#endif
    return true;
}

References Horizon::Zone::ZC_STORE_ITEMLIST_NORMAL_V5::deliver(), Horizon::ClientInterface< ZoneSession >::get_session(), and INVTYPE_STORAGE.

Here is the call graph for this function:

◆ notify_storage_remove_item()

bool ZoneClientInterface::notify_storage_remove_item	(	int16_t	storage_index,
		int	amount
	)

{
    ZC_DELETE_ITEM_FROM_STORE pkt(get_session());
    pkt.deliver(storage_index, amount);
    return true;
}

References Horizon::Zone::ZC_DELETE_ITEM_FROM_STORE::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_storage_size()

bool ZoneClientInterface::notify_storage_size	(	int16_t	total_size,
		int16_t	max_size
	)

{
    ZC_NOTIFY_STOREITEM_COUNTINFO pkt(get_session());
    pkt.deliver(total_size, max_size);
    return true;
}

References Horizon::Zone::ZC_NOTIFY_STOREITEM_COUNTINFO::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_throw_item()

bool ZoneClientInterface::notify_throw_item	(	int16_t	inventory_index,
		int16_t	amount
	)

{
    ZC_ITEM_THROW_ACK pkt(get_session());
    pkt.deliver(inventory_index, amount);
    return true;
}

References Horizon::Zone::ZC_ITEM_THROW_ACK::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_time()

bool ZoneClientInterface::notify_time ( )

{
    ZC_NOTIFY_TIME pkt(get_session());
    pkt.deliver();
    get_session()->clif()->update_session(get_session()->player()->account()._account_id, false);
    return true;
}

References Horizon::Zone::ZC_NOTIFY_TIME::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_unequip_item()

bool ZoneClientInterface::notify_unequip_item	(	std::shared_ptr< const item_entry_data >	item,
		item_unequip_result_type	result
	)

{
    ZC_ACK_TAKEOFF_EQUIP_V5 pkt(get_session());
    pkt.deliver(item->index.inventory, item->current_equip_location_mask, result);
    return true;
}

References Horizon::Zone::ZC_ACK_TAKEOFF_EQUIP_V5::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_unit_move()

bool ZoneClientInterface::notify_unit_move	(	int32_t	guid,
		int32_t	time,
		MapCoords	from,
		MapCoords	to
	)

{
    ZC_NOTIFY_MOVE pkt(get_session());
    pkt.deliver(guid, time, from.x(), from.y(), to.x(), to.y());
    return true;
}

References Horizon::Zone::ZC_NOTIFY_MOVE::deliver(), Horizon::ClientInterface< ZoneSession >::get_session(), Coordinates< MAX_COORDINATES >::x(), and Coordinates< MAX_COORDINATES >::y().

Here is the call graph for this function:

◆ notify_unit_name()

bool ZoneClientInterface::notify_unit_name ( uint32_t guid )

{
    std::shared_ptr<Unit> unit = get_session()->player()->get_nearby_unit(guid);
    
    if (unit == nullptr)
        return false;
 
#if (CLIENT_TYPE == 'M' && PACKET_VERSION >= 20150225) \
    || (CLIENT_TYPE == 'R' && PACKET_VERSION >= 20141126) \
    || (CLIENT_TYPE == 'Z')
    ZC_ACK_REQNAMEALL2 req(get_session());
    req.deliver(guid, std::string(unit->name()) , "", "", "", 0);
#else
    ZC_ACK_REQNAMEALL req(get_session());
    req.deliver(guid, std::string(unit->name()), "", "", "");
#endif
    
    return true;
}

References Horizon::Zone::ZC_ACK_REQNAMEALL2::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_use_item()

bool ZoneClientInterface::notify_use_item	(	std::shared_ptr< item_entry_data >	inv_item,
		bool	success
	)

{
    ZC_USE_ITEM_ACK pkt(get_session());
    pkt.deliver(inv_item->index.inventory, inv_item->amount, success);
    return true;
}

References Horizon::Zone::ZC_USE_ITEM_ACK::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_viewport_add_unit()

bool ZoneClientInterface::notify_viewport_add_unit ( unit_viewport_entry entry )

{
#if PACKET_VERSION >= 20150513
    ZC_NOTIFY_STANDENTRY11 pkt(get_session());
    pkt.deliver(entry);
#endif
    return true;
}

References Horizon::Zone::ZC_NOTIFY_STANDENTRY11::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_viewport_item_entry()

bool ZoneClientInterface::notify_viewport_item_entry ( item_viewport_entry entry )

{
    ZC_ITEM_ENTRY pkt(get_session());
    pkt.deliver(entry);
    return true;
}

References Horizon::Zone::ZC_ITEM_ENTRY::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_viewport_moving_unit()

bool ZoneClientInterface::notify_viewport_moving_unit ( unit_viewport_entry entry )

{
#if PACKET_VERSION >= 20150513
    ZC_NOTIFY_MOVEENTRY11 pkt(get_session());
    pkt.deliver(entry);
#endif
    return true;
}

References Horizon::Zone::ZC_NOTIFY_MOVEENTRY11::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_viewport_remove_unit()

bool ZoneClientInterface::notify_viewport_remove_unit	(	std::shared_ptr< Unit >	unit,
		unit_viewport_notification_type	type
	)

{
    if (unit == nullptr)
         return false;
 
    ZC_NOTIFY_VANISH pkt(get_session());
    pkt.deliver(unit->guid(), type);
    return true;
}

References Horizon::Zone::ZC_NOTIFY_VANISH::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_viewport_spawn_unit()

bool ZoneClientInterface::notify_viewport_spawn_unit ( unit_viewport_entry entry )

{
    ZC_NOTIFY_NEWENTRY11 pkt(get_session());
    pkt.deliver(entry);
    return true;
}

References Horizon::Zone::ZC_NOTIFY_NEWENTRY11::deliver(), and Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ notify_zeny_update()

bool ZoneClientInterface::notify_zeny_update ( )

{
    return true;
}

◆ novice_doridori()

void ZoneClientInterface::novice_doridori ( )

{
 
}

◆ novice_explosion_spirits()

void ZoneClientInterface::novice_explosion_spirits ( )

{
 
}

◆ npc_close()

void ZoneClientInterface::npc_close ( int32_t npc_guid )

{
 
}

◆ npc_contact()

void ZoneClientInterface::npc_contact ( int32_t npc_guid )

{
 
}

◆ npc_input() [1/2]

void ZoneClientInterface::npc_input	(	int	guid,
		int	value
	)

{
 
}

◆ npc_input() [2/2]

void ZoneClientInterface::npc_input	(	int	guid,
		std::string	value
	)

{
 
}

◆ npc_next_dialog()

void ZoneClientInterface::npc_next_dialog ( int32_t npc_guid )

{
 
}

◆ npc_purchase_items()

void ZoneClientInterface::npc_purchase_items ( std::vector< cz_pc_purchase_itemlist > items )

{
 
}

◆ npc_select_deal_type()

void ZoneClientInterface::npc_select_deal_type	(	int	guid,
		cz_ack_select_dealtype	deal_type
	)

{
 
}

◆ npc_select_menu()

void ZoneClientInterface::npc_select_menu	(	int	guid,
		int	choice
	)

{
 
}

◆ npc_sell_items()

void ZoneClientInterface::npc_sell_items ( std::vector< cz_pc_sell_itemlist > items )

{
 
}

◆ npc_weapon_refine()

void ZoneClientInterface::npc_weapon_refine ( int32_t inventory_index )

NPC.

{
 
}

◆ open_buying_store()

void ZoneClientInterface::open_buying_store ( int account_id )

{
 
}

◆ open_vend_shop()

void ZoneClientInterface::open_vend_shop ( int account_id )

Vending.

{
 
}

◆ parse_chat_message()

void ZoneClientInterface::parse_chat_message ( std::string message )

{
    ZC_NOTIFY_PLAYERCHAT notify_player_chat(get_session());
    ZC_NOTIFY_CHAT notify_chat(get_session());
 
    HLog(debug) << get_session()->player()->name() << ": " << message;
 
    int guid = get_session()->player()->guid();
    int msg_first_char = get_session()->player()->name().size() + 3;
 
    // @TODO @commands
    if (message[msg_first_char] == '@') {
        sZone->get_component_of_type<Horizon::Zone::ScriptManager>(Horizon::System::RUNTIME_SCRIPTVM)->player()->perform_command_from_player(get_session()->player(), &message[msg_first_char + 1]);
        return;
    }
 
    ByteBuffer buf;
 
    notify_chat._packet_length = 8 + message.size();
    notify_chat._guid = guid;
    notify_chat._message = message;
    buf = notify_chat.serialize();
    get_session()->player()->notify_in_area(buf, GRID_NOTIFY_AREA_WOS);
    notify_player_chat.deliver(message);
}

References Horizon::Zone::ZC_NOTIFY_PLAYERCHAT::deliver(), Horizon::ClientInterface< ZoneSession >::get_session(), GRID_NOTIFY_AREA_WOS, HLog, message(), notify_chat(), Horizon::System::RUNTIME_SCRIPTVM, and sZone.

Here is the call graph for this function:

◆ party()

UI::Party & Horizon::Zone::ZoneClientInterface::party ( )

inline

62{ return _party; }

References _party.

◆ party_booking()

UI::PartyBooking & Horizon::Zone::ZoneClientInterface::party_booking ( )

inline

63{ return _party_booking; }

References _party_booking.

◆ pet_act_emotion()

void ZoneClientInterface::pet_act_emotion ( cz_pet_act_emotion_type emotion )

{
 
}

◆ pet_evolve()

void ZoneClientInterface::pet_evolve	(	int	evolved_pet_egg_id,
		std::vector< cz_pet_evolution_itemlist >	items
	)

{
    
}

◆ pickup_item()

void ZoneClientInterface::pickup_item ( int guid )

{
    get_session()->player()->pickup_item(guid);
}

References Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ private_airship_request()

void ZoneClientInterface::private_airship_request	(	std::string	map_name,
		int	item_id
	)

{
 
}

◆ produce_item()

void ZoneClientInterface::produce_item	(	int	item_id,
		std::vector< int16_t >	material_ids
	)

{
 
}

◆ progress_bar_completed()

void ZoneClientInterface::progress_bar_completed ( )

{
 
}

◆ pvpinfo()

void ZoneClientInterface::pvpinfo	(	int	character_id,
		int	account_id
	)

{
 
}

◆ quest()

UI::Quest & Horizon::Zone::ZoneClientInterface::quest ( )

inline

66{ return _quest; }

References _quest.

◆ ranking()

void ZoneClientInterface::ranking ( cz_req_ranking_type type )

Ranking.

{
 
}

◆ ranking_alchemist()

void ZoneClientInterface::ranking_alchemist ( )

{
 
}

◆ ranking_blacksmith()

void ZoneClientInterface::ranking_blacksmith ( )

{
 
}

◆ ranking_pk()

void ZoneClientInterface::ranking_pk ( )

{
 
}

◆ recall() [1/2]

void ZoneClientInterface::recall ( int account_id )

{
 
}

◆ recall() [2/2]

void ZoneClientInterface::recall ( std::string username )

{
 
}

◆ register_baby()

void ZoneClientInterface::register_baby	(	int	account_id,
		int	character_id,
		cz_join_baby_reply_type	response
	)

{
 
}

◆ remember_warppoint()

void ZoneClientInterface::remember_warppoint ( )

{
 
}

◆ remove_cart()

void ZoneClientInterface::remove_cart ( )

{
 
}

◆ rename_homunculus()

void ZoneClientInterface::rename_homunculus ( std::string name )

{
 
}

◆ rename_pet()

void ZoneClientInterface::rename_pet ( std::string name )

{
 
}

◆ repair_item()

void ZoneClientInterface::repair_item	(	int	inventory_index,
		int	item_id,
		int	refine,
		int	card1,
		int	card2,
		int	card3,
		int	card4
	)

{
 
}

◆ request_action()

void ZoneClientInterface::request_action	(	int	guid,
		int	target_id,
		int	action
	)

{
 
}

◆ request_name_by_char_id()

void ZoneClientInterface::request_name_by_char_id ( int char_id )

Character.

{
 
}

◆ request_username()

void ZoneClientInterface::request_username ( int account_id )

{
 
}

◆ restart()

bool ZoneClientInterface::restart ( uint8_t type )

All cleanups are managed in ZoneSocket::perform_cleanup.

{
    std::shared_ptr<Horizon::Zone::SCENARIO_GENERIC_TASK> s_task = std::make_shared<Horizon::Zone::SCENARIO_GENERIC_TASK>(sZone->get_component_of_type<Horizon::Zone::ZoneRuntime>(Horizon::System::RUNTIME_RUNTIME)->get_system_routine_manager());
    std::shared_ptr<Horizon::Zone::SCENARIO_GENERIC_TASK::GenericTask> w_task = std::make_shared<Horizon::Zone::SCENARIO_GENERIC_TASK::GenericTask>(s_task);
    s_task->get_runtime_synchronization_mutex().lock();
    s_task->set_session(get_session());
    w_task->set_task([type](std::shared_ptr<Horizon::Zone::SCENARIO_GENERIC_TASK::GenericTask> task) {
        std::shared_ptr<ZoneSession> session = std::dynamic_pointer_cast<Horizon::Zone::ActiveRuntimeScenario>(task->get_runtime_context())->get_session();
        ZC_RESTART_ACK rpkt(session);
        switch (type) {
            case 0:
                task->get_message_agent().set_status_message("Character (GUID:" + std::to_string(session->player()->guid()) + ") is being respawned.");
                session->player()->respawn(0, 0);
                break;
            default:
                task->get_message_agent().set_status_message("Character (GUID:" + std::to_string(session->player()->guid()) + ") has moved to the character server.");
                break;
        };
        rpkt.deliver(type);
    });
    s_task->get_runtime_synchronization_mutex().unlock();
    s_task->push(w_task);
    sZone->get_component_of_type<Horizon::Zone::ZoneRuntime>(Horizon::System::RUNTIME_RUNTIME)->get_system_routine_manager().push(s_task);
 
    return true;
}

References Horizon::Zone::ZC_RESTART_ACK::deliver(), Horizon::ClientInterface< ZoneSession >::get_session(), KernelComponent::get_system_routine_manager(), Horizon::System::RUNTIME_RUNTIME, and sZone.

Here is the call graph for this function:

◆ searchstore_close()

void ZoneClientInterface::searchstore_close ( )

{
 
}

◆ sell_to_buying_store()

void ZoneClientInterface::sell_to_buying_store	(	int	account_id,
		int	store_id,
		std::vector< cz_req_trade_buying_store_itemlist >	items
	)

{
 
}

◆ set_config()

void ZoneClientInterface::set_config	(	cz_config_type	config,
		bool	setting
	)

Config.

{
    switch(config)
    {
    case CZ_CONFIG_OPEN_EQUIPMENT_WINDOW:
        break;
    case CZ_CONFIG_CALL:
        break;
    case CZ_CONFIG_PET_AUTOFEED:
        break;
    case CZ_CONFIG_HOMUNCULUS_AUTOFEED:
        break;
    default:
        break;
    }
}

References CZ_CONFIG_CALL, CZ_CONFIG_HOMUNCULUS_AUTOFEED, CZ_CONFIG_OPEN_EQUIPMENT_WINDOW, and CZ_CONFIG_PET_AUTOFEED.

◆ set_npc_contact_guid()

void Horizon::Zone::ZoneClientInterface::set_npc_contact_guid ( uint32_t guid )

inline

129{ _npc_contact_guid = guid; }

References _npc_contact_guid.

◆ setting_effects()

void ZoneClientInterface::setting_effects ( int setting )

Status.

{
 
}

◆ star_gladiator_feel_save()

void ZoneClientInterface::star_gladiator_feel_save ( cz_agree_starplace_type type )

Class Specific.

{
 
}

◆ start_buying_store()

void ZoneClientInterface::start_buying_store	(	std::string	store_name,
		int	zeny_limit,
		std::vector< cz_req_open_buying_store_itemlist >	items
	)

{
 
}

◆ start_vending()

void ZoneClientInterface::start_vending	(	std::string	shop_name,
		std::vector< cz_req_openstore_itemlist >	items
	)

{
 
}

◆ stop_attack()

bool ZoneClientInterface::stop_attack ( )

{
    get_session()->player()->stop_attack();
    return true;
}

References Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ storage_change_password()

void ZoneClientInterface::storage_change_password	(	std::string	password,
		std::string	new_password
	)

{
 
}

◆ storage_check_password()

void ZoneClientInterface::storage_check_password ( std::string password )

Storage.

{
 
}

◆ storage_close()

void ZoneClientInterface::storage_close ( )

Storage.

{
    notify_storage_close();
    get_session()->player()->set_current_storage_id(0);
}

References Horizon::ClientInterface< ZoneSession >::get_session(), and notify_storage_close().

Here is the call graph for this function:

◆ summon()

void ZoneClientInterface::summon ( std::string char_name )

{
 
}

◆ throw_item()

void ZoneClientInterface::throw_item	(	int16_t	inventory_index,
		int16_t	amount
	)

{
    std::shared_ptr<item_entry_data> item = get_session()->player()->inventory()->get_item(inventory_index);
 
    if (item == nullptr)
        return;
 
    if (item->amount < amount)
        return;
    
    get_session()->player()->throw_item(item, amount);
}

References Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ trade()

UI::Trade & Horizon::Zone::ZoneClientInterface::trade ( )

inline

61{ return _trade; }

References _trade.

◆ unequip_item()

void ZoneClientInterface::unequip_item ( int16_t inventory_index )

{
    get_session()->player()->inventory()->unequip_item(inventory_index);
}

References Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ update_session()

bool ZoneClientInterface::update_session	(	int32_t	account_id,
		bool	first = `true`
	)

{
    std::shared_ptr<boost::mysql::tcp_ssl_connection> conn = sZone->get_database_connection();
 
    if (first == true) {
        boost::mysql::statement stmt = conn->prepare_statement("SELECT `current_server` FROM `session_data` WHERE `id` = ?");
        auto b1 = stmt.bind(account_id);
        boost::mysql::results results;
        conn->execute(b1, results);
        
        HLog(debug) << "Updating session from I.P. address " << get_session()->get_socket()->remote_ip_address();
 
        if (results.rows().empty()) {
            ZC_ACK_REQ_DISCONNECT pkt(get_session());
            HLog(warning) << "Invalid connection for account with ID " << account_id << ", session wasn't found.";
            pkt.deliver(0);
            return false;
        }
 
        auto r = results.rows()[0];
 
        std::string current_server = r[0].as_string();
 
        if (current_server.compare("C") != 0) {
            ZC_ACK_REQ_DISCONNECT pkt(get_session());
            HLog(warning) << "Invalid connection for account with ID " << account_id << ", session wasn't found.";
            pkt.deliver(0);
            return false;
        }
    }
 
    boost::mysql::statement stmt_update_session = conn->prepare_statement("UPDATE `session_data` SET `last_update` = ? WHERE `game_account_id` = ?");
    auto b2 = stmt_update_session.bind(std::time(nullptr), account_id);
    boost::mysql::results results_update_session;
    conn->execute(b2, results_update_session);
 
    return true;
}

References Horizon::Zone::ZC_ACK_REQ_DISCONNECT::deliver(), Horizon::ClientInterface< ZoneSession >::get_session(), HLog, and sZone.

Here is the call graph for this function:

◆ upgrade_skill_level()

void ZoneClientInterface::upgrade_skill_level ( int16_t skill_id )

Skills.

{
    ZC_SKILLINFO_UPDATE pkt(get_session());
    
    std::shared_ptr<skill_learnt_info> ls = get_session()->player()->get_learnt_skill(skill_id);
 
    if (ls == nullptr) {
        skill_learnt_info s;
        s.skill_id = skill_id;
        s.level = 1;
        s.learn_type = SKILL_LEARN_PERMANENT;
        ls = std::make_shared<skill_learnt_info>(s);
        get_session()->player()->add_learnt_skill(ls);
    } else {
        ls->level += 1;
    }
 
    std::shared_ptr<const skill_config_data> skd = SkillDB->get_skill_by_id(ls->skill_id);
 
    bool upgradeable = false;
 
    job_class_type job_id = (job_class_type) get_session()->player()->job_id();
    std::shared_ptr<const skill_tree_config> stc = SkillDB->get_skill_tree_skill_id_by_job_id(job_id, ls->skill_id);
 
    if (stc == nullptr) {
        HLog(error) << "Skill ID " << ls->skill_id << " not found for Job ID " << (int32_t) job_id << ".";
        return;
    }
 
    upgradeable = (ls->level < stc->max_level) ? true : false;
 
    get_session()->player()->status()->skill_point()->sub_base(1);
 
    pkt.deliver(skill_id, ls->level, skd->sp_cost[ls->level], skd->use_range[ls->level], upgradeable);
}

References Horizon::Zone::ZC_SKILLINFO_UPDATE::deliver(), Horizon::ClientInterface< ZoneSession >::get_session(), HLog, skill_learnt_info::learn_type, skill_learnt_info::level, skill_learnt_info::skill_id, SKILL_LEARN_PERMANENT, and SkillDB.

Here is the call graph for this function:

◆ use_item()

void ZoneClientInterface::use_item	(	int16_t	inventory_index,
		int32_t	guid
	)

Items.

{
    get_session()->player()->inventory()->use_item(inventory_index, guid);
}

References Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ use_skill_on_ground() [1/2]

void ZoneClientInterface::use_skill_on_ground	(	int16_t	skill_lv,
		int16_t	skill_id,
		int16_t	pos_x,
		int16_t	pos_y
	)

{
    auto ske = std::make_shared<SkillExecution>(get_session()->player(), skill_id, skill_lv);
    ske->execute(pos_x, pos_y);
}

References Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ use_skill_on_ground() [2/2]

void ZoneClientInterface::use_skill_on_ground	(	int16_t	skill_lv,
		int16_t	skill_id,
		int16_t	pos_x,
		int16_t	pos_y,
		std::string	contents
	)

{
    auto ske = std::make_shared<SkillExecution>(get_session()->player(), skill_id, skill_lv);
    ske->execute(pos_x, pos_y, contents);
}

References Horizon::ClientInterface< ZoneSession >::get_session().

Here is the call graph for this function:

◆ use_skill_on_target()

void ZoneClientInterface::use_skill_on_target	(	int16_t	skill_lv,
		int16_t	skill_id,
		int	target_guid
	)

{
    std::shared_ptr<Unit> target = get_session()->player()->get_nearby_unit(target_guid);
    
    if (target == nullptr)
        return;
    
    std::shared_ptr<const struct skill_config_data> skd = SkillDB->get_skill_by_id(skill_id);
 
    if (skd == nullptr) {
        HLog(error) << "Skill ID " << skill_id << " not found.";
        return;
    }
 
    CombatRegistry::SkillExecutionOperation::SkillExecutionOperand::s_skill_execution_operation_config config;
 
    config.skill_id = skill_id;
    config.skill_lv = skill_lv;
    config.skd = skd;
    config.skill_execution = std::make_shared<SkillExecution>(get_session()->player(), skill_id, skill_lv);
 
    CombatRegistry::SkillExecutionOperation::SkillExecutionOperand *operand = new CombatRegistry::SkillExecutionOperation::SkillExecutionOperand(get_session()->player(), target, config);
    CombatRegistry::SkillExecutionOperation *operation = new CombatRegistry::SkillExecutionOperation(operand, CombatRegistry::SkillExecutionOperation::skill_execution_operation_type::SKILL_EXECUTION_OPERATION_TARGET);
 
    int time = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
    CombatRegistry::CombatStage *stage = get_session()->player()->combat_registry()->create_combat_stage(time);
    stage->add_operation(operation);
    get_session()->player()->combat_registry()->queue_combat_stage(stage);
    
    return;
}

Here is the call graph for this function:

◆ user_count()

void ZoneClientInterface::user_count ( )

{
 
}

◆ vending_purchase_items() [1/2]

void ZoneClientInterface::vending_purchase_items	(	int	account_id,
		int	unique_id,
		std::vector< cz_pc_purchase_itemlist >	items
	)

{
 
}

◆ vending_purchase_items() [2/2]

void ZoneClientInterface::vending_purchase_items	(	int	account_id,
		std::vector< cz_pc_purchase_itemlist >	items
	)

{
 
}

◆ view_equipment()

void ZoneClientInterface::view_equipment ( int account_id )

{
    
}

◆ walk_to_coordinates()

bool ZoneClientInterface::walk_to_coordinates	(	uint16_t	x,
		uint16_t	y,
		uint8_t	dir
	)

{
    std::shared_ptr<Horizon::Zone::SCENARIO_GENERIC_TASK> s_task = std::make_shared<Horizon::Zone::SCENARIO_GENERIC_TASK>(sZone->get_component_of_type<Horizon::Zone::ZoneRuntime>(Horizon::System::RUNTIME_RUNTIME)->get_system_routine_manager());
    std::shared_ptr<Horizon::Zone::SCENARIO_GENERIC_TASK::GenericTask> w_task = std::make_shared<Horizon::Zone::SCENARIO_GENERIC_TASK::GenericTask>(s_task);
    s_task->get_runtime_synchronization_mutex().lock();
    s_task->set_session(get_session());
    w_task->set_task([x, y](std::shared_ptr<Horizon::Zone::SCENARIO_GENERIC_TASK::GenericTask> task) {
        std::shared_ptr<ZoneSession> session = std::dynamic_pointer_cast<Horizon::Zone::ActiveRuntimeScenario>(task->get_runtime_context())->get_session();
 
        if (session->player() == nullptr)
            return;
 
        // This is done here because this is the only place where we can identify that the player has sent a walk request to the server.
        // It is required to stop the player from attacking when they initiate a walking action.
        if (session->player()->is_attacking())
            session->player()->stop_attacking();
            
        session->player()->walk_to_coordinates(x, y);
    });
    s_task->push(w_task);
    int segment_number = sZone->get_segment_number_for_resource<Horizon::Zone::GameLogicProcess, RESOURCE_PRIORITY_TERTIARY, uint64_t, std::shared_ptr<Horizon::Zone::Unit>>(Horizon::System::RUNTIME_GAMELOGIC, get_session()->player()->uuid(), nullptr);
    
    s_task->get_runtime_synchronization_mutex().unlock();
 
    if (segment_number == 0) {
        HLog(warning) << "ZoneClientInterface::walk_to_coordinates:Player " << get_session()->player()->guid() << " is not in a map.";
        return false;
    }
 
    sZone->get_component_of_type<Horizon::Zone::GameLogicProcess>(Horizon::System::RUNTIME_GAMELOGIC, segment_number)->get_system_routine_manager().push(s_task);
 
    return true;
}

References Horizon::ClientInterface< ZoneSession >::get_session(), KernelComponent::get_system_routine_manager(), HLog, RESOURCE_PRIORITY_TERTIARY, Horizon::System::RUNTIME_GAMELOGIC, Horizon::System::RUNTIME_RUNTIME, and sZone.

Here is the call graph for this function:

◆ warp_to()

void ZoneClientInterface::warp_to ( int account_id )

{
 
}

◆ whisper_message()

void ZoneClientInterface::whisper_message	(	const char *	name,
		int32_t	name_length,
		const char *	message,
		int32_t	message_length
	)

{
    // validate name
    // only restriction is that the name must be zero-terminated
    if (name[name_length] != '\0') {
        HLog(warning) << "ZoneClientInterface::whisper_message: Player '" << get_session()->player()->name() << "' sent an unterminated name!\n";
        return;
    }
    // validate name
    // only restriction is that the name must be zero-terminated
    if (message[message_length] != '\0') {
        HLog(warning) << "ZoneClientInterface::whisper_message: Player '" << get_session()->player()->name() << "' sent an unterminated message!\n";
        return;
    }
 
    HLog(debug) << name << " : " << message;
 
    // @TODO
    //std::shared_ptr<Horizon::Zone::Units::Player> player = sZone->get_component_of_type<GameLogicProcess>(Horizon::System::RUNTIME_GAMELOGIC)->find_player(name);
 
    //ZC_ACK_WHISPER02 pkt(get_session());
    //if (player != nullptr)
    //  pkt.deliver(WRT_SUCCESS, player->character()._character_id);
    //else
    //  pkt.deliver(WRT_RECIPIENT_OFFLINE, 0);
//
    //ZC_WHISPER pkt2(player->get_session());
    //pkt2.deliver(get_session()->player()->name(), message, player->account()._group_id >= 99 ? true : false);
}

References Horizon::ClientInterface< ZoneSession >::get_session(), HLog, and message().

Here is the call graph for this function:

Member Data Documentation

◆ _auction

UI::Auction Horizon::Zone::ZoneClientInterface::_auction

protected

Referenced by auction().

◆ _chat_room

UI::Chatroom Horizon::Zone::ZoneClientInterface::_chat_room

protected

Referenced by chatroom().

◆ _clan

UI::Clan Horizon::Zone::ZoneClientInterface::_clan

protected

Referenced by clan().

◆ _friend

UI::Friend Horizon::Zone::ZoneClientInterface::_friend

protected

Referenced by friend_().

◆ _guild

UI::Guild Horizon::Zone::ZoneClientInterface::_guild

protected

Referenced by guild().

◆ _mail

UI::Mail Horizon::Zone::ZoneClientInterface::_mail

protected

Referenced by mail().

◆ _npc_contact_guid

uint32_t Horizon::Zone::ZoneClientInterface::_npc_contact_guid {0}

protected

Referenced by get_npc_contact_guid(), and set_npc_contact_guid().

◆ _party

UI::Party Horizon::Zone::ZoneClientInterface::_party

protected

Referenced by party().

◆ _party_booking

UI::PartyBooking Horizon::Zone::ZoneClientInterface::_party_booking

protected

Referenced by party_booking().

◆ _quest

UI::Quest Horizon::Zone::ZoneClientInterface::_quest

protected

Referenced by quest().

◆ _trade

UI::Trade Horizon::Zone::ZoneClientInterface::_trade

protected

Referenced by trade().

The documentation for this class was generated from the following files:

src/Server/Zone/Interface/ZoneClientInterface.hpp
src/Server/Zone/Interface/ZoneClientInterface.cpp

Public Member Functions

Protected Attributes

Constructor & Destructor Documentation

◆ ZoneClientInterface()

◆ ~ZoneClientInterface()

Member Function Documentation

◆ action_request()

◆ adjust_manner_by_name()

◆ auction()

◆ auto_revive()

◆ bargain_sale_tool_close()

◆ blocking_play_cancel()

◆ broadcast()

◆ broadcast_local()

◆ cash_point_purchase()

◆ change_cart()

◆ change_direction()

◆ change_effect_state()

◆ change_map_type()

◆ chatroom()

◆ check_status()

◆ clan()

◆ client_version()

◆ close_buying_store()

◆ close_vending()

◆ command_mercenary()

◆ command_pet()

◆ create()

◆ create_viewport_entry()

◆ create_viewport_item_entry()

◆ disconnect()

◆ disconnect_account()

◆ disconnect_all_players()

◆ display_item_card_composition()

◆ emotion()

◆ equip_item()

◆ friend_()

◆ get_npc_contact_guid()

◆ give_manner_point()

◆ guild()

◆ identify_item()

◆ ignore_list()

◆ increase_status_point()

◆ invite_baby()

◆ login()

◆ mail()

◆ make_arrow()

◆ make_item()

◆ map_enter()

◆ memorial_dungeon_command()

◆ message()

◆ move_homunculus_to_coordinates()

◆ move_homunculus_to_master()

◆ move_item_from_cart_to_inventory()

◆ move_item_from_cart_to_storage()

◆ move_item_from_inventory_to_cart()

◆ move_item_from_inventory_to_storage()

◆ move_item_from_storage_to_cart()

◆ move_item_from_storage_to_inventory()

◆ move_to_map()

◆ notify_action() [1/2]

◆ notify_action() [2/2]

◆ notify_action_failure()

◆ notify_appearance_update()

◆ notify_attack_range_update()

◆ notify_attribute_update()

◆ notify_bind_on_equip()

◆ notify_buying_store_itemlist()

◆ notify_cart_weight_update()

◆ notify_chat()

◆ notify_compound_attribute_update()

◆ notify_damage()

◆ notify_delete_item()

◆ notify_equip_arrow()

◆ notify_equip_item()

◆ notify_equipment_item_list()

◆ notify_experience_update()

◆ notify_give_manner_point()

◆ notify_hostile_skill_use()

◆ notify_identified_item()