编译成功

2025-06-29 01:38:37 +08:00 · 2025-06-29 01:38:37 +08:00 · c250d01042
parent 0f9264444c
commit c250d01042
14 changed files with 1511 additions and 276 deletions
--- a/ComponentBasic/BehaviorPerform.cpp
+++ b/ComponentBasic/BehaviorPerform.cpp
@ -1,6 +1,31 @@
 #include "BehaviorPerform.h"


+void BehaviorPerformPlugin::mapReset(const QString& path)
+{
+
+}
+
+void BehaviorPerformPlugin::execute(std::shared_ptr<const EntityInitialRequest> in, QList<std::shared_ptr<RespondDefault>>& out)
+{
+
+}
+
+void BehaviorPerformPlugin::execute(std::shared_ptr<const EntityPreparedRequest> in, QList<std::shared_ptr<RespondDefault>>& out)
+{
+
+}
+
+void BehaviorPerformPlugin::execute(std::shared_ptr<const SyncRequest> in, QList<std::shared_ptr<RespondDefault>>& out)
+{
+
+}
+
+void BehaviorPerformPlugin::execute(std::shared_ptr<const DeduceRequest> in, QList<std::shared_ptr<RespondDefault>>& out)
+{
+
+}
+
 void BehaviorPerformPlugin::recoveryFrom(const QJsonObject& obj)
 {
 }
@ -9,32 +34,620 @@ void BehaviorPerformPlugin::saveTo(QJsonObject& obj) const
 {
 }

-std::shared_ptr<WsComponent> BehaviorPerformPlugin::defaultNew() const
+std::shared_ptr<Serializable> BehaviorPerformPlugin::newDefault() const
 {
-    return std::make_shared<BehaviorPerformPlugin>();
+	return std::make_shared<BehaviorPerformPlugin>();
 }

 void BehaviorPerformPlugin::bindEntity(std::weak_ptr<WsEntity> host)
 {
-    this->_bind_entity = host;
+	this->_bind_entity = host;
 }

 QString BehaviorPerformPlugin::name() const
 {
-    return NAME(BehaviorPerformPlugin);
+	return NAME(BehaviorPerformPlugin);
 }

-void MapHost::setVariable(const QString& key, std::shared_ptr<TopicData> ins)
-{
-	if (_variable_map.contains(key) && _variable_map[key]->topicString() != ins->typeName())
-		throw new UniException("不同数据类型数据绑定同一个名称！");
-	_variable_map[key] = ins;
+#include <MessageLoader.h>
+MapKernal::MapKernal(std::shared_ptr<MessageLoader> ins)
+	: _bind_loader(ins) {
+	for (auto key : ins->allType())
+		registData(ins->makeDefault(key));
 }

-std::shared_ptr<TopicData> MapHost::getVariable(const QString& key) const
+QList<QString> MapKernal::compareTypes() const
 {
-	if(!_variable_map.contains(key))
+	return _compare_types.keys();
+}
+
+void MapKernal::registCompare(std::shared_ptr<CompareKernel> ins)
+{
+	_compare_types[ins->name()] = ins;
+}
+
+std::shared_ptr<CompareKernel> MapKernal::getCompare(const QString& name)
+{
+	if (!_compare_types.contains(name))
+		return nullptr;
+	return _compare_types[name];
+}
+
+void MapKernal::registConvert(std::shared_ptr<ConvertKernel> ins)
+{
+	_convert_types[ins->name()] = ins;
+}
+
+QList<QString> MapKernal::convertTypes() const
+{
+	return _convert_types.keys();
+}
+
+std::shared_ptr<ConvertKernel> MapKernal::getConvert(const QString& name)
+{
+	if (!_convert_types.contains(name))
+		return nullptr;
+	return _convert_types[name];
+}
+
+std::shared_ptr<MessageLoader> MapKernal::messageLoader() const
+{
+	return this->_bind_loader;
+}
+
+void MapKernal::registData(std::shared_ptr<TopicData> init)
+{
+	if (_variable_types.contains(init->topicString()))
+		throw new UniException(QString("重复注册类型数据{%1}").arg(init->topicString()));
+
+	_variable_types[init->topicString()] = init;
+}
+
+QList<QString> MapKernal::dataTypes() const
+{
+	return _variable_types.keys();
+}
+
+std::shared_ptr<TopicData> MapKernal::getData(const QString& topic)
+{
+	return _variable_types[topic];
+}
+
+std::shared_ptr<Serializable> MapKernal::newDefault() const
+{
+	return nullptr;
+}
+
+LogicalNode::LogicalNode(NodeKind t /*= NodeKind::ACTIONNODE*/)
+	:_node_type(t) {
+}
+
+void LogicalNode::setParent(std::weak_ptr<LogicalNode> pnode)
+{
+	this->_parent_bind = pnode;
+}
+
+NodeKind LogicalNode::kind() const
+{
+	return _node_type;
+}
+
+std::shared_ptr<LogicalNode> LogicalNode::bindParentMap() const
+{
+	auto node_temp = this->getBackwards().lock();
+	if (!node_temp) return nullptr;
+
+	while (node_temp->kind() != NodeKind::MAPNODE) {
+		node_temp = node_temp->getBackwards().lock();
+	}
+	return node_temp;
+}
+
+void LogicalNode::setID(int unique_id)
+{
+	this->_node_id = unique_id;
+}
+
+int LogicalNode::getID() const
+{
+	return this->_node_id;
+}
+
+QString LogicalNode::runtimeName() const
+{
+	return QString("%1(%2)").arg(this->typeName()).arg(getID());
+}
+
+std::weak_ptr<LogicalNode> LogicalNode::getBackwards() const
+{
+	return this->_parent_bind;
+}
+
+BehaviorMapNode::BehaviorMapNode(std::shared_ptr<MessageLoader> core)
+	:LogicalNode(NodeKind::MAPNODE), MapKernal(core) {
+}
+
+void BehaviorMapNode::setVariable(const QString& key, IO_TYPE t, std::shared_ptr<TopicData> ins)
+{
+	if (_variables.contains(key))
+		if (_variables[key].second->topicString() != ins->topicString())
+			throw new UniException("不同数据类型数据绑定同一个名称！");
+	_variables[key] = std::make_pair(t, ins);
+}
+
+std::shared_ptr<TopicData> BehaviorMapNode::getVariable(const QString& key) const
+{
+	if (!_variables.contains(key))
 		return nullptr;

-	return _variable_map[key];
+	return _variables[key].second;
+}
+
+void BehaviorMapNode::resetName(const QString& val)
+{
+	this->_map_name = val;
+}
+
+std::shared_ptr<Serializable> BehaviorMapNode::newDefault() const
+{
+	return std::make_shared<BehaviorMapNode>(this->messageLoader());
+}
+
+void BehaviorMapNode::recoveryFrom(const QJsonObject& obj)
+{
+
+}
+
+void BehaviorMapNode::saveTo(QJsonObject& obj) const
+{
+
+}
+
+QList<std::shared_ptr<LogicalNode>> BehaviorMapNode::getForwards() const
+{
+	return children();
+}
+
+bool BehaviorMapNode::fallback(std::shared_ptr<LogicalNode> node, LogicalResult ste)
+{
+	this->_state_value = ste;
+	return true;
+}
+
+void BehaviorMapNode::reset()
+{
+	this->_state_value = LogicalResult::UNDEFINED;
+}
+
+QString BehaviorMapNode::typeName() const
+{
+	return _map_name;
+}
+
+LogicalResult BehaviorMapNode::execute()
+{
+	return _state_value;
+}
+
+QHash<QString, std::shared_ptr<TopicData>> BehaviorMapNode::inputList() const
+{
+	QHash<QString, std::shared_ptr<TopicData>> list;
+	for (auto key : this->_variables.keys()) {
+		if (this->_variables[key].first == IO_TYPE::INPUT && key.contains("::"))
+			list[key] = _variables[key].second;
+	}
+
+	return list;
+}
+
+QHash<QString, std::shared_ptr<TopicData>> BehaviorMapNode::outputList() const
+{
+	QHash<QString, std::shared_ptr<TopicData>> list;
+	for (auto key : this->_variables.keys()) {
+		if (this->_variables[key].first == IO_TYPE::OUTPUT && key.contains("::"))
+			list[key] = _variables[key].second;
+	}
+
+	return list;
+}
+
+SequenceNode::SequenceNode()
+	: LogicalNode(NodeKind::SEQUENCENODE) {
+}
+
+QList<std::shared_ptr<LogicalNode>> SequenceNode::getForwards() const
+{
+	for (auto item : children()) {
+		// 子节点执行失败，提前结束
+		if (_state_map.contains(item->getID())) {
+			if (_state_map[item->getID()] != LogicalResult::SUCCESS)
+				return QList<std::shared_ptr<LogicalNode>>();
+		}
+
+		// 获取新节点
+		if (!_state_map.contains(item->getID()))
+			return QList<std::shared_ptr<LogicalNode>>() << item;
+	}
+
+	// 全部成功
+	return QList<std::shared_ptr<LogicalNode>>();
+}
+
+QString SequenceNode::typeName() const
+{
+	return "顺序节点";
+}
+
+LogicalResult SequenceNode::execute() {
+	if (children().size() >= _state_map.size())
+		return LogicalResult::FAILURE;
+
+	for (auto ste : this->_state_map) {
+		switch (ste) {
+		case LogicalResult::SUCCESS:
+			break;
+		default:
+			return LogicalResult::FAILURE;
+		}
+	}
+
+	return LogicalResult::SUCCESS;
+}
+
+QHash<QString, std::shared_ptr<TopicData>> SequenceNode::inputList() const
+{
+	return QHash<QString, std::shared_ptr<TopicData>>();
+}
+
+QHash<QString, std::shared_ptr<TopicData>> SequenceNode::outputList() const
+{
+	return QHash<QString, std::shared_ptr<TopicData>>();
+}
+
+void SequenceNode::recoveryFrom(const QJsonObject& obj)
+{
+	QStringList state_items;
+	STRLIST_PEAK(state_items);
+	for (auto kv : state_items) {
+		auto kv_pair = kv.split(":");
+		_state_map[kv_pair[0].toInt()] = (LogicalResult)kv_pair[1].toInt();
+	}
+}
+
+void SequenceNode::saveTo(QJsonObject& obj) const
+{
+	QStringList state_items;
+	for (auto inv : _state_map.keys()) {
+		state_items << QString("%1:%2").arg(inv).arg((int)_state_map[inv]);
+	}
+
+	STRLIST_SAVE(state_items);
+}
+
+bool SequenceNode::fallback(std::shared_ptr<LogicalNode> node, LogicalResult ste)
+{
+	this->_state_map[node->getID()] = ste;
+	return true;
+}
+
+std::shared_ptr<Serializable> SequenceNode::newDefault() const
+{
+	return std::make_shared<SequenceNode>();
+}
+
+void SequenceNode::reset()
+{
+	this->_state_map.clear();
+}
+
+QList<std::shared_ptr<LogicalNode>> ComposeNode::children() const
+{
+	return _child_list;
+}
+
+void ComposeNode::insert(std::shared_ptr<LogicalNode> node, int index /*= -1*/)
+{
+	for (auto it : _child_list)
+		if (it->getID() == node->getID())
+			return;
+
+	_child_list.insert(index, node);
+}
+
+void ComposeNode::remove(std::shared_ptr<LogicalNode> node)
+{
+	_child_list.removeAll(node);
+}
+
+SelectorNode::SelectorNode()
+	: LogicalNode(NodeKind::SEQUENCENODE) {
+}
+
+QList<std::shared_ptr<LogicalNode>> SelectorNode::getForwards() const
+{
+	for (auto item : children()) {
+		// 子节点执行失败，提前结束
+		if (_state_map.contains(item->getID())) {
+			if (_state_map[item->getID()] == LogicalResult::SUCCESS)
+				return QList<std::shared_ptr<LogicalNode>>();
+		}
+
+		// 获取新节点
+		if (!_state_map.contains(item->getID()))
+			return QList<std::shared_ptr<LogicalNode>>() << item;
+	}
+
+	// 全部成功
+	return QList<std::shared_ptr<LogicalNode>>();
+}
+
+bool SelectorNode::fallback(std::shared_ptr<LogicalNode> node, LogicalResult ste)
+{
+	_state_map[node->getID()] = ste;
+	return true;
+}
+
+std::shared_ptr<Serializable> SelectorNode::newDefault() const
+{
+	return std::make_shared<SelectorNode>();
+}
+
+void SelectorNode::recoveryFrom(const QJsonObject& obj)
+{
+	QStringList state_items;
+	STRLIST_PEAK(state_items);
+	for (auto kv : state_items) {
+		auto kv_pair = kv.split(":");
+		_state_map[kv_pair[0].toInt()] = (LogicalResult)kv_pair[1].toInt();
+	}
+}
+
+void SelectorNode::saveTo(QJsonObject& obj) const
+{
+	QStringList state_items;
+	for (auto inv : _state_map.keys()) {
+		state_items << QString("%1:%2").arg(inv).arg((int)_state_map[inv]);
+	}
+
+	STRLIST_SAVE(state_items);
+}
+
+void SelectorNode::reset()
+{
+	_state_map.clear();
+}
+
+QString SelectorNode::typeName() const
+{
+	return "选择节点";
+}
+
+LogicalResult SelectorNode::execute()
+{
+	for (auto value : _state_map) {
+		if (value == LogicalResult::SUCCESS)
+			return LogicalResult::SUCCESS;
+	}
+	return LogicalResult::FAILURE;
+}
+
+QHash<QString, std::shared_ptr<TopicData>> SelectorNode::inputList() const
+{
+	return {};
+}
+
+QHash<QString, std::shared_ptr<TopicData>> SelectorNode::outputList() const
+{
+	return {};
+}
+
+QList<std::shared_ptr<LogicalNode>> ParallelNode::getForwards() const
+{
+	if (this->children().size() == _state_map.size())
+		return QList<std::shared_ptr<LogicalNode>>();
+	return this->children();
+}
+
+bool ParallelNode::fallback(std::shared_ptr<LogicalNode> node, LogicalResult ste)
+{
+	_state_map[node->getID()] = ste;
+	return children().size() == _state_map.size();
+}
+
+void ParallelNode::reset()
+{
+	_state_map.clear();
+}
+
+QString ParallelNode::typeName() const
+{
+	return "并行节点";
+}
+
+LogicalResult ParallelNode::execute()
+{
+	for (auto ste : this->_state_map)
+		if (ste != LogicalResult::SUCCESS)
+			return LogicalResult::FAILURE;
+
+	return LogicalResult::SUCCESS;
+}
+
+std::shared_ptr<Serializable> ParallelNode::newDefault() const
+{
+	return std::make_shared<ParallelNode>();
+}
+
+ParallelNode::ParallelNode()
+	: LogicalNode(NodeKind::PARALLELNODE) {
+}
+
+QHash<QString, std::shared_ptr<TopicData>> ParallelNode::inputList() const
+{
+	return QHash<QString, std::shared_ptr<TopicData>>();
+}
+
+QHash<QString, std::shared_ptr<TopicData>> ParallelNode::outputList() const
+{
+	return QHash<QString, std::shared_ptr<TopicData>>();
+}
+
+void ParallelNode::recoveryFrom(const QJsonObject& obj)
+{
+	QStringList state_items;
+	STRLIST_PEAK(state_items);
+	for (auto kv : state_items) {
+		auto kv_pair = kv.split(":");
+		_state_map[kv_pair[0].toInt()] = (LogicalResult)kv_pair[1].toInt();
+	}
+}
+
+void ParallelNode::saveTo(QJsonObject& obj) const
+{
+	QStringList state_items;
+	for (auto inv : _state_map.keys()) {
+		state_items << QString("%1:%2").arg(inv).arg((int)_state_map[inv]);
+	}
+
+	STRLIST_SAVE(state_items);
+}
+
+void CompareNode::reset() {
+}
+
+QString CompareNode::typeName() const
+{
+	return QString("%1<%2>").arg("比较节点", delegateName());
+}
+
+LogicalResult CompareNode::execute()
+{
+	if (this->_bind_delegate) {
+		auto vl = _data_map["左值"];
+		auto vb = _data_map["右值"];
+		if (this->_bind_delegate->compare(vl, vb))
+			return LogicalResult::SUCCESS;
+	}
+	return LogicalResult::FAILURE;
+}
+
+std::shared_ptr<Serializable> CompareNode::newDefault() const
+{
+	return std::make_shared<CompareNode>();
+}
+
+CompareNode::CompareNode()
+	: LogicalNode(NodeKind::COMPARENODE) {
+	_data_map["左值"] = std::make_shared<GeneralData>();
+	_data_map["右值"] = std::make_shared<GeneralData>();
+}
+
+QString CompareNode::delegateName() const
+{
+	if (_bind_delegate)
+		return _bind_delegate->name();
+	return "";
+}
+
+void CompareNode::bindDelegate(std::shared_ptr<CompareKernel> ins)
+{
+	this->_bind_delegate = ins;
+}
+
+QHash<QString, std::shared_ptr<TopicData>> CompareNode::inputList() const
+{
+	return _data_map;
+}
+
+QHash<QString, std::shared_ptr<TopicData>> CompareNode::outputList() const
+{
+	return QHash<QString, std::shared_ptr<TopicData>>();
+}
+
+void CompareNode::recoveryFrom(const QJsonObject& obj)
+{
+	auto vala = obj["ValL"];
+	auto valb = obj["ValR"];
+
+	_data_map["左值"]->recoveryFrom(vala.toObject());
+	_data_map["右值"]->recoveryFrom(valb.toObject());
+}
+
+void CompareNode::saveTo(QJsonObject& obj) const
+{
+	QJsonObject vala, valb;
+	_data_map["左值"]->saveTo(vala);
+	_data_map["右值"]->saveTo(valb);
+
+	obj["ValL"] = vala;
+	obj["ValR"] = valb;
+}
+
+#include <QJsonDocument>
+QString GeneralData::topicString() const
+{
+	return "GeneralData";
+}
+
+std::shared_ptr<Serializable> GeneralData::newDefault() const
+{
+	return std::make_shared<GeneralData>();
+}
+
+void GeneralData::recoveryFrom(const QJsonObject& obj)
+{
+	_element_bind = obj;
+}
+
+void GeneralData::saveTo(QJsonObject& obj) const
+{
+	obj = _element_bind;
+}
+
+CompareKernel::CompareKernel(QJSEngine& bind_engine, const QString& func)
+	:_script_engine(bind_engine), _function_name(func) {
+}
+
+QString CompareKernel::name() const
+{
+	return _function_name;
+}
+
+bool CompareKernel::compare(std::shared_ptr<TopicData> vleft, std::shared_ptr<TopicData> vright)
+{
+	return true;
+}
+
+ConvertKernel::ConvertKernel(std::shared_ptr<MapKernal> host, QJSEngine& bind_engine, const QString& func)
+	: _host_bind(host), _script_engine(bind_engine), _function_name(func) {
+}
+
+QString ConvertKernel::name() const
+{
+	return _function_name;
+}
+
+QList<std::pair<ConvertKernel::DATA_TOPIC_STRING, QString>> ConvertKernel::inputTable() const
+{
+	return _input_table;
+}
+
+void ConvertKernel::inputReset(const QList<std::pair<DATA_TOPIC_STRING, QString>>& table)
+{
+	this->_input_table = table;
+}
+
+std::pair<ConvertKernel::DATA_TOPIC_STRING, QString> ConvertKernel::outputVariable() const
+{
+	return _output_appoint;
+}
+
+void ConvertKernel::outputReset(std::pair<DATA_TOPIC_STRING, QString> appoint)
+{
+	this->_output_appoint = appoint;
+}
+
+std::shared_ptr<TopicData> ConvertKernel::convert(const QList<std::shared_ptr<TopicData>>& input_variables)
+{
+	return nullptr;
 }
--- a/ComponentBasic/BehaviorPerform.h
+++ b/ComponentBasic/BehaviorPerform.h
@ -2,116 +2,609 @@

 #include "componentbasic.h"
 #include <messagebasic.h>
+#include <QJsonObject>
+#include <QJSEngine>
+
+class MessageLoader;
+class CompareKernel;
+class ConvertKernel;
+class LogicalNode;

 /// <summary>
 /// 行为树实例化节点
 /// </summary>
-class COMPONENTBASIC_EXPORT MapHost : public Serializable {
+class COMPONENTBASIC_EXPORT MapKernal : virtual public Serializable {
 private:
 	/// <summary>
-	/// {Topic，init-value}
+	/// 绑定载入器
+	/// </summary>
+	std::shared_ptr<MessageLoader> _bind_loader;
+
+	/// <summary>
+	/// {Topic，default-value}
 	/// </summary>
 	QHash<QString, std::shared_ptr<TopicData>> _variable_types;
+
 	/// <summary>
-	/// 变量表
+	/// 比较器
 	/// </summary>
-	QHash<QString, std::shared_ptr<TopicData>> _variable_map;
+	QHash<QString, std::shared_ptr<CompareKernel>> _compare_types;
+	/// <summary>
+	/// 转换器
+	/// </summary>
+	QHash<QString, std::shared_ptr<ConvertKernel>> _convert_types;
+
+	/// <summary>
+	/// 所有可用的节点类型
+	/// </summary>
+	QHash<QString, std::shared_ptr<LogicalNode>> _logicalnode_types;

 public:
-	virtual ~MapHost() = default;
+	MapKernal(std::shared_ptr<MessageLoader> ins);
+	virtual ~MapKernal() = default;
+
+	/// <summary>
+	/// 获取MessageLoader单例
+	/// </summary>
+	/// <returns></returns>
+	std::shared_ptr<MessageLoader> messageLoader() const;
+
+	// 数据类型管理 ======================================================
 	/// <summary>
 	/// 注册数据类型
 	/// </summary>
 	/// <param name="init"></param>
-	virtual void registData(std::shared_ptr<TopicData> init) = 0;
+	virtual void registData(std::shared_ptr<TopicData> init);
+	/// <summary>
+	/// 获取所有可用数据类型
+	/// </summary>
+	/// <returns></returns>
+	virtual QList<QString> dataTypes() const;
+	/// <summary>
+	/// 获取指定topic的数据类型
+	/// </summary>
+	/// <param name="topic"></param>
+	/// <returns></returns>
+	virtual std::shared_ptr<TopicData> getData(const QString &topic);
+
+
+
+	// 比较器类型管理 ======================================================
+	/// <summary>
+	/// 注册比较器
+	/// </summary>
+	/// <param name="ins"></param>
+	virtual void registCompare(std::shared_ptr<CompareKernel> ins);
+	/// <summary>
+	/// 获取比较器类型
+	/// </summary>
+	/// <returns></returns>
+	virtual QList<QString> compareTypes() const;
+	/// <summary>
+	/// 获取比较器单例实例
+	/// </summary>
+	/// <param name="name"></param>
+	/// <returns></returns>
+	virtual std::shared_ptr<CompareKernel> getCompare(const QString& name);
+
+
+
+	// 转换器类型管理 ======================================================
+	/// <summary>
+	/// 注册转换器
+	/// </summary>
+	/// <param name="ins"></param>
+	virtual void registConvert(std::shared_ptr<ConvertKernel> ins);
+	/// <summary>
+	/// 转换器类型名称
+	/// </summary>
+	/// <returns></returns>
+	virtual QList<QString> convertTypes() const;
+	/// <summary>
+	/// 获取指定类型的转换器
+	/// </summary>
+	/// <param name="name"></param>
+	/// <returns></returns>
+	virtual std::shared_ptr<ConvertKernel> getConvert(const QString& name);
+
+
+	// 通过 Serializable 继承
+	std::shared_ptr<Serializable> newDefault() const override;
+	void recoveryFrom(const QJsonObject& obj) override{}
+	void saveTo(QJsonObject& obj) const override{}
+};
+
+
+/// <summary>
+/// 比较关系实例
+/// </summary>
+class COMPONENTBASIC_EXPORT CompareKernel {
+private:
+	QJSEngine& _script_engine;
+	QString _function_name;
+
+public:
+	CompareKernel(QJSEngine& bind_engine, const QString& func);
+
+	QString name() const;
+	bool compare(std::shared_ptr<TopicData> vleft, std::shared_ptr<TopicData> vright);
+};
+/// <summary>
+/// 数据转换实例
+/// </summary>
+class COMPONENTBASIC_EXPORT ConvertKernel {
+public:
+	typedef QString DATA_TOPIC_STRING;
+
+	/// <summary>
+	/// 构建转换器
+	/// </summary>
+	/// <param name="host">数据类型管理核心</param>
+	/// <param name="bind_engine"></param>
+	/// <param name="func"></param>
+	ConvertKernel(std::shared_ptr<MapKernal> host, QJSEngine& bind_engine, const QString& func);
+	/// <summary>
+	/// 转换器名称：JS函数名
+	/// </summary>
+	/// <returns></returns>
+	QString name() const;
+
+	/// <summary>
+	/// 输入变量类型绑定表
+	/// </summary>
+	/// <returns>list{pair{类型名称,绑定输入变量名}}</returns>
+	QList<std::pair<DATA_TOPIC_STRING, QString>> inputTable() const;
+	/// <summary>
+	/// 重置输入变量类型表
+	/// </summary>
+	/// <param name="table">list{pair{类型名称,绑定输入变量名}}</param>
+	void inputReset(const QList<std::pair<DATA_TOPIC_STRING, QString>> &table);
+	/// <summary>
+	/// 输入变量
+	/// </summary>
+	/// <returns>pair{类型名称,绑定输出变量名}</returns>
+	std::pair<DATA_TOPIC_STRING, QString> outputVariable() const;
+	/// <summary>
+	/// 重置输出变量类型名
+	/// </summary>
+	/// <param name="appoint"></param>
+	void outputReset(std::pair<DATA_TOPIC_STRING, QString> appoint);
+
+	/// <summary>
+	/// 执行转换
+	/// </summary>
+	/// <param name="input_variables">输入变量列表</param>
+	/// <returns></returns>
+	std::shared_ptr<TopicData> convert(const QList<std::shared_ptr<TopicData>>& input_variables);
+
+private:
+	std::shared_ptr<MapKernal> _host_bind;
+
+	QJSEngine& _script_engine;
+	QString _function_name;
+
+	QList<std::pair<DATA_TOPIC_STRING, QString>> _input_table;
+	std::pair<DATA_TOPIC_STRING, QString> _output_appoint;
+};
+
+/// <summary>
+/// 执行结果
+/// </summary>
+enum class LogicalResult {
+	UNDEFINED,	// 未定义
+	SUCCESS,	// 成功
+	FAILURE		// 失败
+};
+
+/// <summary>
+/// 逻辑节点类型
+/// </summary>
+enum class NodeKind {
+	MAPNODE,		// 逻辑树节点
+	SEQUENCENODE,	// 顺序节点
+	SELECTORNODE,	// 选择节点
+	PARALLELNODE,	// 并行节点
+	COMPARENODE,	// 比较节点
+	ACTIONNODE,		// 动作节点
+};
+
+/// <summary>
+/// 通用数据类型
+/// </summary>
+struct COMPONENTBASIC_EXPORT GeneralData : public TopicData {
+	QJsonObject _element_bind;
+
+	QString topicString() const override;
+	std::shared_ptr<Serializable> newDefault() const override;
+
+	void recoveryFrom(const QJsonObject& obj) override;
+	void saveTo(QJsonObject& obj) const override;
+};
+
+/// <summary>
+/// 所有逻辑节点的基类
+/// </summary>
+class COMPONENTBASIC_EXPORT LogicalNode : virtual public Serializable {
+private:
+	int _node_id = 0;
+	NodeKind _node_type = NodeKind::ACTIONNODE;
+	std::weak_ptr<LogicalNode> _parent_bind;
+	QList<std::shared_ptr<LogicalNode>> _child_list;
+
+public:
+	LogicalNode(NodeKind t = NodeKind::ACTIONNODE);
+	virtual ~LogicalNode() = default;
+
+	/// <summary>
+	/// 重置父节点
+	/// </summary>
+	/// <param name="pnode"></param>
+	void setParent(std::weak_ptr<LogicalNode> pnode);
+
+	/// <summary>
+	/// 获取节点类型
+	/// </summary>
+	/// <returns></returns>
+	NodeKind kind() const;
+	/// <summary>
+	/// 获取包含树图节点
+	/// </summary>
+	/// <returns></returns>
+	std::shared_ptr<LogicalNode> bindParentMap() const;
+
+	/// <summary>
+	/// 设置节点id
+	/// </summary>
+	/// <param name="unique_id"></param>
+	void setID(int unique_id);
+	/// <summary>
+	/// 提取节点id
+	/// </summary>
+	/// <returns></returns>
+	int getID() const;
+	/// <summary>
+	/// 实例化节点名称
+	/// </summary>
+	/// <returns></returns>
+	QString runtimeName() const;
+	/// <summary>
+	/// 回退节点
+	/// </summary>
+	/// <returns></returns>
+	std::weak_ptr<LogicalNode> getBackwards() const;
+
+	/// <summary>
+	/// 重置内部状态
+	/// </summary>
+	virtual void reset() = 0;
+	/// <summary>
+	/// 获取节点名称
+	/// </summary>
+	/// <returns></returns>
+	virtual QString typeName() const = 0;
+	/// <summary>
+	/// 执行逻辑节点
+	/// </summary>
+	/// <param name="core"></param>
+	/// <returns></returns>
+	virtual LogicalResult execute() = 0;
+	/// <summary>
+	/// 声明输入变量的内部标识和数据接口
+	/// </summary>
+	/// <returns>map{name, type-ins}</returns>
+	virtual QHash<QString, std::shared_ptr<TopicData>> inputList() const = 0;
+	/// <summary>
+	/// 声明输出变量的内部标识和数据接口
+	/// </summary>
+	/// <returns>map{name, type-ins}</returns>
+	virtual QHash<QString, std::shared_ptr<TopicData>> outputList() const = 0;
+
+	/// <summary>
+	/// 新建默认实例
+	/// </summary>
+	/// <returns></returns>
+	virtual std::shared_ptr<Serializable> newDefault() const = 0;
+};
+
+/// <summary>
+/// 组合节点
+/// </summary>
+class COMPONENTBASIC_EXPORT ComposeNode {
+private:
+	QList<std::shared_ptr<LogicalNode>> _child_list;
+
+public:
+	/// <summary>
+	/// 获取子节点列表
+	/// </summary>
+	/// <returns></returns>
+	virtual QList<std::shared_ptr<LogicalNode>> children() const;
+	/// <summary>
+	/// 添加子节点
+	/// </summary>
+	/// <param name="node"></param>
+	/// <param name="index"></param>
+	virtual void insert(std::shared_ptr<LogicalNode> node, int index = -1);
+	/// <summary>
+	/// 移除子节点
+	/// </summary>
+	/// <param name="node"></param>
+	virtual void remove(std::shared_ptr<LogicalNode> node);
+
+	/// <summary>
+	/// 获取执行入口节点
+	/// </summary>
+	/// <returns></returns>
+	virtual QList<std::shared_ptr<LogicalNode>> getForwards() const = 0;
+	/// <summary>
+	/// 下行节点执行状态回返填充
+	/// </summary>
+	/// <param name="node"></param>
+	/// <param name="ste"></param>
+	/// <returns>接续执行标志</returns>
+	virtual bool fallback(std::shared_ptr<LogicalNode> node, LogicalResult ste) = 0;
+};
+
+/// <summary>
+/// 逻辑树节点输入输出类型
+/// </summary>
+enum class IO_TYPE {
+	INPUT, OUTPUT
+};
+/// <summary>
+/// 自定义行为树节点根节点实例
+/// </summary>
+class COMPONENTBASIC_EXPORT BehaviorMapNode
+	: public MapKernal, public LogicalNode, public ComposeNode {
+private:
+	/// <summary>
+	/// 地图变量表
+	/// </summary>
+	QHash<QString, std::pair<IO_TYPE, std::shared_ptr<TopicData>>> _variables;
+	QString _map_name;
+	LogicalResult _state_value;
+
+public:
+	BehaviorMapNode(std::shared_ptr<MessageLoader> core);
+
+
 	/// <summary>
 	/// 设置变量，如果类型错误会抛出UniException异常
 	/// 节点初始化时会按照配置注册默认值变量
 	/// </summary>
-	virtual void setVariable(const QString& key, std::shared_ptr<TopicData> ins);
+	virtual void setVariable(const QString& key, IO_TYPE t, std::shared_ptr<TopicData> ins);
 	/// <summary>
 	/// 获取指定名称的数据变量
 	/// </summary>
 	/// <param name="key"></param>
 	/// <returns>如果不存在指定名称数据，返回nullptr，类型不确定</returns>
 	virtual std::shared_ptr<TopicData> getVariable(const QString& key) const;
-};

-/// <summary>
-/// 所有逻辑节点的基类
-/// </summary>
-class LogicalNode : public Serializable {
-public:
-	virtual ~LogicalNode() = default;

-	/// <summary>
-	/// 设置节点id
-	/// </summary>
-	/// <param name="unique_id"></param>
-	virtual void setID(int unique_id) = 0;
-	/// <summary>
-	/// 提取节点id
-	/// </summary>
-	/// <returns></returns>
-	virtual int getID() const = 0;
-	/// <summary>
-	/// 获取节点名称
-	/// </summary>
-	/// <returns></returns>
-	virtual QString name() const = 0;
-
-	/// <summary>
-	/// 获取子节点列表
-	/// </summary>
-	/// <returns></returns>
-	virtual QList<std::shared_ptr<LogicalNode>> children() const = 0;
-
-	/// <summary>
-	/// 声明输入变量的内部标识和数据接口
-	/// </summary>
-	/// <returns>map{name, type}</returns>
-	virtual QHash<QString, std::shared_ptr<TopicData>> inputDeclares() const = 0;
-	/// <summary>
-	/// 声明输出变量的内部标识和数据接口
-	/// </summary>
-	/// <returns>map{name, type}</returns>
-	virtual QHash<QString, std::shared_ptr<TopicData>> outputDeclares() const = 0;
-};
-
-/// <summary>
-/// 自定义行为树节点实例
-/// </summary>
-class COMPONENTBASIC_EXPORT BehaviorMapNode : public MapHost, public LogicalNode {
-public:
-	/// <summary>
-	/// 重置行为树数据文件
-	/// </summary>
-	/// <param name="path"></param>
-	virtual void setBehaviorMap(const QString &path){}
 	/// <summary>
 	/// 设置行为树节点名称
 	/// </summary>
 	/// <param name="val"></param>
-	virtual void resetName(const QString &val){}
+	virtual void resetName(const QString& val);
+	/// <summary>
+	/// 重置执行状态
+	/// </summary>
+	void reset() override;
+	/// <summary>
+	/// 获取节点类型名称
+	/// </summary>
+	/// <returns></returns>
+	QString typeName() const override;
+
+	/// <summary>
+	/// 提取前置节点
+	/// </summary>
+	/// <returns></returns>
+	QList<std::shared_ptr<LogicalNode>> getForwards() const override;
+	/// <summary>
+	/// 填充状态
+	/// </summary>
+	/// <param name="node"></param>
+	/// <param name="ste"></param>
+	/// <returns></returns>
+	bool fallback(std::shared_ptr<LogicalNode> node, LogicalResult ste) override;
+
+	/// <summary>
+	/// 执行状态
+	/// </summary>
+	/// <returns></returns>
+	LogicalResult execute() override;
+
+	/// <summary>
+	/// 输入变量列表
+	/// </summary>
+	/// <returns></returns>
+	QHash<QString, std::shared_ptr<TopicData>> inputList() const override;
+	/// <summary>
+	/// 输出变量列表
+	/// </summary>
+	/// <returns></returns>
+	QHash<QString, std::shared_ptr<TopicData>> outputList() const override;
+
+	/// <summary>
+	/// 创建新实例
+	/// </summary>
+	/// <param name="p"></param>
+	/// <returns></returns>
+	virtual std::shared_ptr<Serializable> newDefault() const override;
+	void recoveryFrom(const QJsonObject& obj) override;
+	void saveTo(QJsonObject& obj) const override;
 };

+// 行为树节点 ======================================================
+
+/// <summary>
+/// 顺序节点
+/// </summary>
+class COMPONENTBASIC_EXPORT SequenceNode
+	: public ComposeNode, public LogicalNode {
+private:
+	QHash<int, LogicalResult> _state_map;
+
+public:
+	SequenceNode();
+
+	QList<std::shared_ptr<LogicalNode>> getForwards() const override;
+	QString typeName() const override;
+
+	LogicalResult execute() override;
+	QHash<QString, std::shared_ptr<TopicData>> inputList() const override;
+	QHash<QString, std::shared_ptr<TopicData>> outputList() const override;
+
+	void reset() override;
+	bool fallback(std::shared_ptr<LogicalNode> node, LogicalResult ste) override;
+
+	/// <summary>
+	/// 新实例
+	/// </summary>
+	/// <param name="p"></param>
+	/// <returns></returns>
+	virtual std::shared_ptr<Serializable> newDefault() const override;
+
+	void recoveryFrom(const QJsonObject& obj) override;
+	void saveTo(QJsonObject& obj) const override;
+};
+
+/// <summary>
+/// 选择节点
+/// </summary>
+class COMPONENTBASIC_EXPORT SelectorNode
+	: public ComposeNode, public LogicalNode {
+private:
+	QHash<int, LogicalResult> _state_map;
+
+public:
+	SelectorNode();
+
+	QList<std::shared_ptr<LogicalNode>> getForwards() const override;
+	QString typeName() const override;
+
+	LogicalResult execute() override;
+	QHash<QString, std::shared_ptr<TopicData>> inputList() const override;
+	QHash<QString, std::shared_ptr<TopicData>> outputList() const override;
+
+	void reset() override;
+	bool fallback(std::shared_ptr<LogicalNode> node, LogicalResult ste) override;
+
+	/// <summary>
+	/// 新实例
+	/// </summary>
+	/// <param name="p"></param>
+	/// <returns></returns>
+	virtual std::shared_ptr<Serializable> newDefault() const override;
+
+	void recoveryFrom(const QJsonObject& obj) override;
+	void saveTo(QJsonObject& obj) const override;
+};
+
+/// <summary>
+/// 并行节点
+/// </summary>
+class COMPONENTBASIC_EXPORT ParallelNode
+	: public ComposeNode, public LogicalNode {
+private:
+	QHash<int, LogicalResult> _state_map;
+
+public:
+	ParallelNode();
+
+	QHash<QString, std::shared_ptr<TopicData>> inputList() const override;
+	QHash<QString, std::shared_ptr<TopicData>> outputList() const override;
+
+	QString typeName() const override;
+
+	QList<std::shared_ptr<LogicalNode>> getForwards() const override;
+	bool fallback(std::shared_ptr<LogicalNode> node, LogicalResult ste) override;
+
+	LogicalResult execute() override;
+	void reset() override;
+
+	/// <summary>
+	/// 新实例
+	/// </summary>
+	/// <param name="p"></param>
+	/// <returns></returns>
+	virtual std::shared_ptr<Serializable> newDefault() const override;
+
+	void recoveryFrom(const QJsonObject& obj) override;
+	void saveTo(QJsonObject& obj) const override;
+};
+
+/// <summary>
+/// 比较节点
+/// </summary>
+class COMPONENTBASIC_EXPORT CompareNode : public LogicalNode {
+private:
+	std::shared_ptr<CompareKernel> _bind_delegate;
+	QHash<QString, std::shared_ptr<TopicData>> _data_map;
+
+public:
+	CompareNode();
+
+	/// <summary>
+	/// 委托名称
+	/// </summary>
+	/// <returns></returns>
+	QString delegateName() const;
+	/// <summary>
+	/// 绑定比较委托
+	/// </summary>
+	/// <param name="ins"></param>
+	void bindDelegate(std::shared_ptr<CompareKernel> ins);
+
+	QHash<QString, std::shared_ptr<TopicData>> inputList() const override;
+	QHash<QString, std::shared_ptr<TopicData>> outputList() const override;
+
+	QString typeName() const override;
+	LogicalResult execute() override;
+
+	void reset() override;
+
+	/// <summary>
+	/// 新实例
+	/// </summary>
+	/// <param name="p"></param>
+	/// <returns></returns>
+	virtual std::shared_ptr<Serializable> newDefault() const override;
+
+	void recoveryFrom(const QJsonObject& obj) override;
+	void saveTo(QJsonObject& obj) const override;
+};
+
+// 行为节点 ====================================================================
+
 /// <summary>
 /// 行为树组件
 /// </summary>
-class COMPONENTBASIC_EXPORT BehaviorPerformPlugin : public ProcList<
-	WsRespond<SyncRequest, RespondDefault>
->{
+class COMPONENTBASIC_EXPORT BehaviorPerformPlugin :
+public RespondRoute<
+	WsRespond<EntityInitialRequest, RespondDefault>,
+	WsRespond<EntityPreparedRequest, RespondDefault>,
+	WsRespond<SyncRequest, RespondDefault>,
+	WsRespond<DeduceRequest, RespondDefault>>,
+public RequestRoute<> 
+{
 private:
 	std::weak_ptr<WsEntity> _bind_entity;

 public:
+	void mapReset(const QString &path);
+
 	// 通过 ProcList 继承
-	void execute(std::shared_ptr<Immediate> map, std::shared_ptr<const SyncRequest> in, QList<std::shared_ptr<RespondDefault>>& out) override;
+	void execute(std::shared_ptr<const EntityInitialRequest> in, QList<std::shared_ptr<RespondDefault>>& out) override;
+	void execute(std::shared_ptr<const EntityPreparedRequest> in, QList<std::shared_ptr<RespondDefault>>& out) override;
+	void execute(std::shared_ptr<const SyncRequest> in, QList<std::shared_ptr<RespondDefault>>& out) override;
+	void execute(std::shared_ptr<const DeduceRequest> in, QList<std::shared_ptr<RespondDefault>>& out) override;

 	void recoveryFrom(const QJsonObject& obj) override;
 	void saveTo(QJsonObject& obj) const override;

-	std::shared_ptr<WsComponent> defaultNew() const override;
+	std::shared_ptr<Serializable> newDefault() const override;
 	void bindEntity(std::weak_ptr<WsEntity> host) override;
 	QString name() const override;
 };
--- a/ComponentBasic/ComponentBasic.vcxproj
+++ b/ComponentBasic/ComponentBasic.vcxproj
@ -37,7 +37,7 @@
  </ImportGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'" Label="QtSettings">
    <QtInstall>5.12.11_msvc2017_64</QtInstall>
-    <QtModules>core;gui;concurrent</QtModules>
+    <QtModules>core;xml;gui;qml;concurrent</QtModules>
    <QtBuildConfig>debug</QtBuildConfig>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'" Label="QtSettings">
--- a/ComponentBasic/ComponentsInfoPull.cpp
+++ b/ComponentBasic/ComponentsInfoPull.cpp
@ -14,7 +14,7 @@ QString ComponentsInfoPull::name() const

 #include <QVariant>
 #include <QJsonArray>
-void ComponentsInfoPull::execute(std::shared_ptr<Immediate> map,
+void ComponentsInfoPull::execute(
 	std::shared_ptr<const ComponentDatasQuery> in, QList<std::shared_ptr<ComponentDatasQueryResult>>& out)
 {
 	auto rst = std::make_shared<ComponentDatasQueryResult>();
@ -44,7 +44,7 @@ void ComponentsInfoPull::execute(std::shared_ptr<Immediate> map,
 }

 #include <internal_impl.h>
-void ComponentsInfoPull::execute(std::shared_ptr<Immediate> map,
+void ComponentsInfoPull::execute(
 	std::shared_ptr<const ProcedureSignatureQuery> in, QList<std::shared_ptr<ProcedureSignatureQueryResult>>& out)
 {
 	auto ent_ins = std::dynamic_pointer_cast<ComponentSet>(this->_bind_entity.lock());
@ -53,12 +53,12 @@ void ComponentsInfoPull::execute(std::shared_ptr<Immediate> map,
 	auto result = std::make_shared<ProcedureSignatureQueryResult>();
 	result->reset(in->targetEntity(), in->sourceEntity());
 	for (auto cp : comps) {
-		result->_signature_list.append(cp->signatureTypes());
+		result->_signature_list.append(cp->respondSignatures());
 	}
 	out << result;
 }

-std::shared_ptr<WsComponent> ComponentsInfoPull::defaultNew() const
+std::shared_ptr<Serializable> ComponentsInfoPull::newDefault() const
 {
 	return std::make_shared<ComponentsInfoPull>();
 }
--- a/ComponentBasic/ComponentsInfoPull.h
+++ b/ComponentBasic/ComponentsInfoPull.h
@ -1,14 +1,16 @@
 #pragma once
-#include <messagebasic.h>
+#include <componentinfo_access.h>
 #include "componentbasic.h"

 /// <summary>
 /// 组件信息提取
 /// </summary>
-class COMPONENTBASIC_EXPORT ComponentsInfoPull : public ProcList<
+class COMPONENTBASIC_EXPORT ComponentsInfoPull : 
+public RespondRoute<
 	WsRespond<ComponentDatasQuery, ComponentDatasQueryResult>,
-	WsRespond<ProcedureSignatureQuery, ProcedureSignatureQueryResult>
-> {
+	WsRespond<ProcedureSignatureQuery, ProcedureSignatureQueryResult>>,
+public RequestRoute<> 
+{
 private:
 	std::weak_ptr<WsEntity> _bind_entity;

@ -19,10 +21,10 @@ public:
 	void bindEntity(std::weak_ptr<WsEntity> ins) override;
 	QString name() const override;

-	void execute(std::shared_ptr<Immediate> map, std::shared_ptr<const ComponentDatasQuery> in, QList<std::shared_ptr<ComponentDatasQueryResult>>& out) override;
-	void execute(std::shared_ptr<Immediate> map, std::shared_ptr<const ProcedureSignatureQuery> in, QList<std::shared_ptr<ProcedureSignatureQueryResult>>& out) override;
+	void execute(std::shared_ptr<const ComponentDatasQuery> in, QList<std::shared_ptr<ComponentDatasQueryResult>>& out) override;
+	void execute(std::shared_ptr<const ProcedureSignatureQuery> in, QList<std::shared_ptr<ProcedureSignatureQueryResult>>& out) override;

-	std::shared_ptr<WsComponent> defaultNew() const override;
+	std::shared_ptr<Serializable> newDefault() const override;
 	void recoveryFrom(const QJsonObject& obj) override;
 	void saveTo(QJsonObject& obj) const override;
 };
--- a/ComponentBasic/DeduceFramework.cpp
+++ b/ComponentBasic/DeduceFramework.cpp
@ -9,13 +9,11 @@ QList<std::shared_ptr<WsMessage>> deduct_each(std::shared_ptr<WsEntity> item)
 	QMutexLocker loc(&DeduceFramework::_static_mutex);

 	QList<std::shared_ptr<WsMessage>> rets;
-	auto immediate = std::make_shared<ImmediateKernel>(item);
-
 	for (auto msg : DeduceFramework::_accept_stack) {
 		if (msg->targetEntity() == item->entityID()) {
-			auto enters = item->getEntryWithInType(msg->topicString());
-			for (auto e : enters)
-				e(immediate, msg, rets);
+			auto enters = item->getRespondWithInType(msg->topicString());
+			for (auto efunc : enters)
+				efunc(msg, rets);
 		}
 	}
 	return rets;
@ -54,7 +52,7 @@ void DeduceFramework::deduceBegin(std::shared_ptr<const DeduceRequest> ins)
 }

 #include <simsbasic.h>
-#include "InvisibleComponent.h"
+#include "ComponentsInfoPull.h"
 DeduceFramework::DeduceFramework()
 	:_factory_ins(std::make_shared<ComponentFactory>()) {
 }
@ -76,7 +74,7 @@ void DeduceFramework::init_framework()
 	this->_entity_map_over_0xffff[res_e->entityID()] = res_e;
 }

-std::shared_ptr<WsComponent> DeduceFramework::defaultNew() const
+std::shared_ptr<Serializable> DeduceFramework::newDefault() const
 {
 	throw std::logic_error("The method or operation is not implemented.");
 }
@ -101,7 +99,7 @@ void DeduceFramework::saveTo(QJsonObject& obj) const
 	throw std::logic_error("The method or operation is not implemented.");
 }

-void DeduceFramework::execute(std::shared_ptr<Immediate> map,
+void DeduceFramework::execute(
 	std::shared_ptr<const EntityOperate> in, QList<std::shared_ptr<RespondDefault>>& out)
 {
 	auto dt = QTime::currentTime();
@ -111,60 +109,60 @@ void DeduceFramework::execute(std::shared_ptr<Immediate> map,

 	switch ((EntityOperateType)in->_operate_code)
 	{
-		case EntityOperateType::NEW: {
-			if (!this->_templets_within_0x2ff_0xffff.contains(in->_template_name)) {
-				result->_reason_text = QString("指定的Template：%1不存在").arg(in->_template_name);
-			}
-			else {
-				result->_success_mark = true;
+	case EntityOperateType::NEW: {
+		if (!this->_templets_within_0x2ff_0xffff.contains(in->_template_name)) {
+			result->_reason_text = QString("指定的Template：%1不存在").arg(in->_template_name);
+		}
+		else {
+			result->_success_mark = true;

-				auto ins_t = this->_templets_within_0x2ff_0xffff[in->_template_name];
-				auto new_copy = std::static_pointer_cast<RtWsEntity>(ins_t->defaultNew());
-				new_copy->resetID(0xffff);
-				auto desc_p = std::make_shared<ComponentsInfoPull>();
-				new_copy->append(desc_p);
+			auto ins_t = this->_templets_within_0x2ff_0xffff[in->_template_name];
+			auto new_copy = std::static_pointer_cast<RtWsEntity>(ins_t->newDefault());
+			new_copy->resetID(0xffff);
+			auto desc_p = std::make_shared<ComponentsInfoPull>();
+			new_copy->append(desc_p);

-				while (_entity_map_over_0xffff.contains(new_copy->entityID()))
-				{
-					auto ncode = new_copy->entityID() + 1;
-					new_copy->resetID(ncode);
-				}
-				_entity_map_over_0xffff[new_copy->entityID()] = new_copy;
+			while (_entity_map_over_0xffff.contains(new_copy->entityID()))
+			{
+				auto ncode = new_copy->entityID() + 1;
+				new_copy->resetID(ncode);
 			}
-		}break;
-		case EntityOperateType::DELETE: {
-			if (!this->_entity_map_over_0xffff.contains(in->_entity_id_over_0xffff)) {
-				result->_reason_text = QString("指定的实体id：%1不存在").arg(in->_entity_id_over_0xffff);
-			}
-			else {
-				result->_success_mark = true;
-				this->_entity_map_over_0xffff.remove(in->_entity_id_over_0xffff);
-			}
-		}break;
-		case EntityOperateType::MODIFY: {
-			if (!this->_entity_map_over_0xffff.contains(in->_entity_id_over_0xffff)) {
-				result->_reason_text = QString("指定的实体id：%1不存在").arg(in->_entity_id_over_0xffff);
-			}
-			else {
-				result->_success_mark = true;
+			_entity_map_over_0xffff[new_copy->entityID()] = new_copy;
+		}
+	}break;
+	case EntityOperateType::DELETE: {
+		if (!this->_entity_map_over_0xffff.contains(in->_entity_id_over_0xffff)) {
+			result->_reason_text = QString("指定的实体id：%1不存在").arg(in->_entity_id_over_0xffff);
+		}
+		else {
+			result->_success_mark = true;
+			this->_entity_map_over_0xffff.remove(in->_entity_id_over_0xffff);
+		}
+	}break;
+	case EntityOperateType::MODIFY: {
+		if (!this->_entity_map_over_0xffff.contains(in->_entity_id_over_0xffff)) {
+			result->_reason_text = QString("指定的实体id：%1不存在").arg(in->_entity_id_over_0xffff);
+		}
+		else {
+			result->_success_mark = true;

-				auto target_ins = std::static_pointer_cast<RtWsEntity>(
-					this->_entity_map_over_0xffff[in->_entity_id_over_0xffff]
-				);
-				target_ins->resetName(in->_entity_name);
-				target_ins->resetTemplet(in->_template_name);
-			}
-		}break;
-		default:
-			result->_reason_text = QString("指定操作码非法：%1").arg(in->_operate_code);
-			break;
+			auto target_ins = std::static_pointer_cast<RtWsEntity>(
+				this->_entity_map_over_0xffff[in->_entity_id_over_0xffff]
+			);
+			target_ins->resetName(in->_entity_name);
+			target_ins->resetTemplet(in->_template_name);
+		}
+	}break;
+	default:
+		result->_reason_text = QString("指定操作码非法：%1").arg(in->_operate_code);
+		break;
 	}

 	result->_time_consume = dt.msecsTo(QTime::currentTime());
 	out << result;
 }

-void DeduceFramework::execute(std::shared_ptr<Immediate> map,
+void DeduceFramework::execute(
 	std::shared_ptr<const EntityTotalGet> in, QList<std::shared_ptr<EntityTotalList>>& out)
 {
 	auto rst = std::make_shared<EntityTotalList>();
@ -173,7 +171,7 @@ void DeduceFramework::execute(std::shared_ptr<Immediate> map,
 	out << rst;
 }

-void DeduceFramework::execute(std::shared_ptr<Immediate> map,
+void DeduceFramework::execute(
 	std::shared_ptr<const TypesQuery> in, QList<std::shared_ptr<TypesQueryResult>>& out)
 {
 	auto ins = std::make_shared<TypesQueryResult>();
@ -188,7 +186,7 @@ void DeduceFramework::execute(std::shared_ptr<Immediate> map,
 	out << ins;
 }

-void DeduceFramework::execute(std::shared_ptr<Immediate> map,
+void DeduceFramework::execute(
 	std::shared_ptr<const TempletOperate> in, QList<std::shared_ptr<RespondDefault>>& out)
 {
 	auto dt = QTime::currentTime();
@ -197,68 +195,68 @@ void DeduceFramework::execute(std::shared_ptr<Immediate> map,
 	nins->reset(in->targetEntity(), in->sourceEntity());

 	switch ((EntityOperateType)in->_operate_code) {
-		case EntityOperateType::NEW: {
-			nins->_success_mark = true;
-			auto ent_t = std::make_shared<RtWsEntity>();
-			ent_t->resetID(0x2ff);
-			ent_t->resetTemplet(in->_template_name);
+	case EntityOperateType::NEW: {
+		nins->_success_mark = true;
+		auto ent_t = std::make_shared<RtWsEntity>();
+		ent_t->resetID(0x2ff);
+		ent_t->resetTemplet(in->_template_name);

-			auto desc_p = std::make_shared<ComponentsInfoPull>();
-			ent_t->append(desc_p);
+		auto desc_p = std::make_shared<ComponentsInfoPull>();
+		ent_t->append(desc_p);

-			// 提取所有的模板id
-			auto _tm_ins = _templets_within_0x2ff_0xffff.values();
-			QList<uint64_t> allids;
-			std::transform(_templets_within_0x2ff_0xffff.begin(), _templets_within_0x2ff_0xffff.end(),
-				std::back_inserter(allids), [](std::shared_ptr<RtWsEntity> i) { return i->entityID(); });
+		// 提取所有的模板id
+		auto _tm_ins = _templets_within_0x2ff_0xffff.values();
+		QList<uint64_t> allids;
+		std::transform(_templets_within_0x2ff_0xffff.begin(), _templets_within_0x2ff_0xffff.end(),
+			std::back_inserter(allids), [](std::shared_ptr<RtWsEntity> i) { return i->entityID(); });

-			// 重置模板id
-			while (allids.contains(ent_t->entityID())) {
-				auto nid = ent_t->entityID() + 1;
-				ent_t->resetID(nid);
+		// 重置模板id
+		while (allids.contains(ent_t->entityID())) {
+			auto nid = ent_t->entityID() + 1;
+			ent_t->resetID(nid);
+		}
+
+		// 模板载入系统
+		_templets_within_0x2ff_0xffff[in->_template_name] = ent_t;
+	}break;
+	case EntityOperateType::DELETE: {
+		for (auto ekey : this->_templets_within_0x2ff_0xffff.keys()) {
+			auto eins = this->_templets_within_0x2ff_0xffff[ekey];
+			nins->_success_mark = false;
+			nins->_reason_text = QString("指定的实体id：%1不存在").arg(in->_template_id_within_0x2ff_0xffff);
+
+			if (eins->entityID() == in->_template_id_within_0x2ff_0xffff) {
+				this->_templets_within_0x2ff_0xffff.remove(ekey);
+				nins->_success_mark = true;
+				nins->_reason_text = "";
+				break;
 			}
+		}
+	}break;
+	case EntityOperateType::MODIFY: {
+		for (auto ekey : this->_templets_within_0x2ff_0xffff.keys()) {
+			auto eins = this->_templets_within_0x2ff_0xffff[ekey];
+			nins->_reason_text = QString("指定的实体id：%1不存在").arg(in->_template_id_within_0x2ff_0xffff);
+			nins->_success_mark = false;

-			// 模板载入系统
-			_templets_within_0x2ff_0xffff[in->_template_name] = ent_t;
-		}break;
-		case EntityOperateType::DELETE: {
-			for (auto ekey : this->_templets_within_0x2ff_0xffff.keys()) {
-				auto eins = this->_templets_within_0x2ff_0xffff[ekey];
-				nins->_success_mark = false;
-				nins->_reason_text = QString("指定的实体id：%1不存在").arg(in->_template_id_within_0x2ff_0xffff);
-
-				if (eins->entityID() == in->_template_id_within_0x2ff_0xffff) {
-					this->_templets_within_0x2ff_0xffff.remove(ekey);
-					nins->_success_mark = true;
-					nins->_reason_text = "";
-					break;
-				}
+			if (eins->entityID() == in->_template_id_within_0x2ff_0xffff) {
+				eins->resetTemplet(in->_template_name);
+				nins->_success_mark = true;
+				nins->_reason_text = "";
+				break;
 			}
-		}break;
-		case EntityOperateType::MODIFY: {
-			for (auto ekey : this->_templets_within_0x2ff_0xffff.keys()) {
-				auto eins = this->_templets_within_0x2ff_0xffff[ekey];
-				nins->_reason_text = QString("指定的实体id：%1不存在").arg(in->_template_id_within_0x2ff_0xffff);
-				nins->_success_mark = false;
-
-				if (eins->entityID() == in->_template_id_within_0x2ff_0xffff) {
-					eins->resetTemplet(in->_template_name);
-					nins->_success_mark = true;
-					nins->_reason_text = "";
-					break;
-				}
-			}
-		}break;
-		default:
-			nins->_reason_text = QString("指定操作码非法：%1").arg(in->_operate_code);
-			break;
+		}
+	}break;
+	default:
+		nins->_reason_text = QString("指定操作码非法：%1").arg(in->_operate_code);
+		break;
 	}

 	nins->_time_consume = dt.msecsTo(QTime::currentTime());
 	out << nins;
 }

-void DeduceFramework::execute(std::shared_ptr<Immediate> map,
+void DeduceFramework::execute(
 	std::shared_ptr<const ComponentOperate> in, QList<std::shared_ptr<RespondDefault>>& out)
 {
 	auto dt = QTime::currentTime();
@ -341,7 +339,7 @@ std::shared_ptr<WsComponent> ComponentFactory::makeNew(const QString& type)
 		return NULL;

 	auto ntype = _comp_types[type];
-	return ntype->defaultNew();
+	return std::static_pointer_cast<WsComponent>(ntype->newDefault());
 }

 QList<QString> ComponentFactory::allComponentTypes() const
@ -349,6 +347,11 @@ QList<QString> ComponentFactory::allComponentTypes() const
 	return _comp_types.keys();
 }

+std::shared_ptr<Serializable> ComponentFactory::newDefault() const
+{
+	return nullptr;
+}
+
 void ComponentFactory::recoveryFrom(const QJsonObject& obj)
 {
 	QStringList tlist;
--- a/ComponentBasic/DeduceFramework.h
+++ b/ComponentBasic/DeduceFramework.h
@ -5,6 +5,7 @@
 #include <QObject>
 #include <QHash>
 #include <QMutex>
+#include <entity_operate.h>

 class COMPONENTBASIC_EXPORT ComponentFactory : public Serializable {
 private:
@ -17,18 +18,20 @@ public:
 	QList<QString> allComponentTypes() const;

 	// Í¨¹ý Serializable ¼Ì³Ð
+	std::shared_ptr<Serializable> newDefault() const override;
 	void recoveryFrom(const QJsonObject& obj) override;
 	void saveTo(QJsonObject& obj) const override;

 };

 class COMPONENTBASIC_EXPORT DeduceFramework : public QObject,
-public ProcList<
+public RespondRoute<
 	WsRespond<TypesQuery, TypesQueryResult>,
 	WsRespond<TempletOperate, RespondDefault>,
 	WsRespond<EntityOperate, RespondDefault>,
 	WsRespond<ComponentOperate, RespondDefault>,
-	WsRespond<EntityTotalGet, EntityTotalList>>
+	WsRespond<EntityTotalGet, EntityTotalList>>,
+public RequestRoute<>
 {
 	Q_OBJECT
 private:
@ -71,15 +74,15 @@ public:
 	void init_framework();

 	// ProcList interface =======================================================
-	std::shared_ptr<WsComponent> defaultNew() const override;
+	std::shared_ptr<Serializable> newDefault() const override;
 	void bindEntity(std::weak_ptr<WsEntity> ins) override;
 	QString name() const override;
 	void recoveryFrom(const QJsonObject& obj) override;
 	void saveTo(QJsonObject& obj) const override;

-	void execute(std::shared_ptr<Immediate> map, std::shared_ptr<const TypesQuery> in, QList<std::shared_ptr<TypesQueryResult>>& out) override;
-	void execute(std::shared_ptr<Immediate> map, std::shared_ptr<const TempletOperate> in, QList<std::shared_ptr<RespondDefault>>& out) override;
-	void execute(std::shared_ptr<Immediate> map, std::shared_ptr<const EntityOperate> in, QList<std::shared_ptr<RespondDefault>>& out) override;
-	void execute(std::shared_ptr<Immediate> map, std::shared_ptr<const ComponentOperate> in, QList<std::shared_ptr<RespondDefault>>& out) override;
-	void execute(std::shared_ptr<Immediate> map, std::shared_ptr<const EntityTotalGet> in, QList<std::shared_ptr<EntityTotalList>>& out) override;
+	void execute(std::shared_ptr<const TypesQuery> in, QList<std::shared_ptr<TypesQueryResult>>& out) override;
+	void execute(std::shared_ptr<const TempletOperate> in, QList<std::shared_ptr<RespondDefault>>& out) override;
+	void execute(std::shared_ptr<const EntityOperate> in, QList<std::shared_ptr<RespondDefault>>& out) override;
+	void execute(std::shared_ptr<const ComponentOperate> in, QList<std::shared_ptr<RespondDefault>>& out) override;
+	void execute(std::shared_ptr<const EntityTotalGet> in, QList<std::shared_ptr<EntityTotalList>>& out) override;
 };
--- a/ComponentBasic/RouteManage.cpp
+++ b/ComponentBasic/RouteManage.cpp
@ -8,7 +8,7 @@ PlainRouteManagePlugin::PlainRouteManagePlugin()

 #include <QJsonArray>

-void PlainRouteManagePlugin::execute(std::shared_ptr<Immediate> map, std::shared_ptr<const NewPlainRoute> in, QList<std::shared_ptr<RespondDefault>>& out)
+void PlainRouteManagePlugin::execute(std::shared_ptr<const NewPlainRoute> in, QList<std::shared_ptr<RespondDefault>>& out)
 {
 	auto resp = std::make_shared<RespondDefault>();
 	resp->reset(in->targetEntity(), in->sourceEntity());
@ -24,7 +24,7 @@ void PlainRouteManagePlugin::execute(std::shared_ptr<Immediate> map, std::shared
 	out << resp;
 }

-void PlainRouteManagePlugin::execute(std::shared_ptr<Immediate> map, std::shared_ptr<const RemovePlainRoute> in, QList<std::shared_ptr<RespondDefault>>& out)
+void PlainRouteManagePlugin::execute(std::shared_ptr<const RemovePlainRoute> in, QList<std::shared_ptr<RespondDefault>>& out)
 {
 	auto resp = std::make_shared<RespondDefault>();
 	resp->reset(in->targetEntity(), in->sourceEntity());
@ -40,7 +40,7 @@ void PlainRouteManagePlugin::execute(std::shared_ptr<Immediate> map, std::shared
 	out << resp;
 }

-void PlainRouteManagePlugin::execute(std::shared_ptr<Immediate> map, std::shared_ptr<const PlainRouteReset> in, QList<std::shared_ptr<RespondDefault>>& out)
+void PlainRouteManagePlugin::execute(std::shared_ptr<const PlainRouteReset> in, QList<std::shared_ptr<RespondDefault>>& out)
 {
 	auto resp = std::make_shared<RespondDefault>();
 	resp->reset(in->targetEntity(), in->sourceEntity());
@ -59,7 +59,7 @@ void PlainRouteManagePlugin::execute(std::shared_ptr<Immediate> map, std::shared
 	out << resp;
 }

-void PlainRouteManagePlugin::execute(std::shared_ptr<Immediate> map, std::shared_ptr<const PlainRouteQuery> in, QList<std::shared_ptr<PlainRouteInfo>>& out)
+void PlainRouteManagePlugin::execute(std::shared_ptr<const PlainRouteQuery> in, QList<std::shared_ptr<PlainRouteInfo>>& out)
 {
 	auto resp = std::make_shared<PlainRouteInfo>();
 	resp->reset(in->targetEntity(), in->sourceEntity());
@ -116,7 +116,7 @@ void PlainRouteManagePlugin::saveTo(QJsonObject& obj) const
 	obj["total_route"] = route_array;
 }

-std::shared_ptr<WsComponent> PlainRouteManagePlugin::defaultNew() const
+std::shared_ptr<Serializable> PlainRouteManagePlugin::newDefault() const
 {
 	return nullptr;
 }
--- a/ComponentBasic/RouteManage.h
+++ b/ComponentBasic/RouteManage.h
@ -15,12 +15,14 @@ struct RouteResource {
 /// <summary>
 /// 平面路径管理插件
 /// </summary>
-class COMPONENTBASIC_EXPORT PlainRouteManagePlugin : public ProcList<
+class COMPONENTBASIC_EXPORT PlainRouteManagePlugin : 
+public RespondRoute<
 	WsRespond<NewPlainRoute, RespondDefault>,
 	WsRespond<RemovePlainRoute, RespondDefault>,
 	WsRespond<PlainRouteReset, RespondDefault>,
-	WsRespond<PlainRouteQuery, PlainRouteInfo>
-> {
+	WsRespond<PlainRouteQuery, PlainRouteInfo>>,
+public RequestRoute<>
+{
 private:
 	std::weak_ptr<WsEntity> _bind_entity;
 	QHash<QString, RouteResource> _route_resource_map;
@ -29,15 +31,15 @@ public:
 	PlainRouteManagePlugin();

 	// 通过 ProcList 继承
-	void execute(std::shared_ptr<Immediate> map, std::shared_ptr<const NewPlainRoute> in, QList<std::shared_ptr<RespondDefault>>& out) override;
-	void execute(std::shared_ptr<Immediate> map, std::shared_ptr<const RemovePlainRoute> in, QList<std::shared_ptr<RespondDefault>>& out) override;
-	void execute(std::shared_ptr<Immediate> map, std::shared_ptr<const PlainRouteReset> in, QList<std::shared_ptr<RespondDefault>>& out) override;
-	void execute(std::shared_ptr<Immediate> map, std::shared_ptr<const PlainRouteQuery> in, QList<std::shared_ptr<PlainRouteInfo>>& out) override;
+	void execute(std::shared_ptr<const NewPlainRoute> in, QList<std::shared_ptr<RespondDefault>>& out) override;
+	void execute(std::shared_ptr<const RemovePlainRoute> in, QList<std::shared_ptr<RespondDefault>>& out) override;
+	void execute(std::shared_ptr<const PlainRouteReset> in, QList<std::shared_ptr<RespondDefault>>& out) override;
+	void execute(std::shared_ptr<const PlainRouteQuery> in, QList<std::shared_ptr<PlainRouteInfo>>& out) override;

 	void recoveryFrom(const QJsonObject& obj) override;
 	void saveTo(QJsonObject& obj) const override;

-	std::shared_ptr<WsComponent> defaultNew() const override;
+	std::shared_ptr<Serializable> newDefault() const override;
 	void bindEntity(std::weak_ptr<WsEntity> host) override;
 	QString name() const override;
 };
--- a/ComponentBasic/SurfaceMotion.cpp
+++ b/ComponentBasic/SurfaceMotion.cpp
@ -13,7 +13,7 @@ void SurfaceMotionPlugin::saveTo(QJsonObject& obj) const
 {
 }

-void SurfaceMotionPlugin::execute(std::shared_ptr<Immediate> map,
+void SurfaceMotionPlugin::execute(
 	std::shared_ptr<const HorizontalArcMotion> in, QList<std::shared_ptr<RespondDefault>>& out)
 {
 	auto exec_result = std::make_shared<RespondDefault>();
@ -22,12 +22,12 @@ void SurfaceMotionPlugin::execute(std::shared_ptr<Immediate> map,
 		auto exec = std::make_shared<MotionDeduceRequest>();
 		exec->reset(in->targetEntity(), in->sourceEntity());
 		exec->_target_time = _current_cmd->startTimepoint();
-		map->execute(exec);
+		this->query(this->_bind_entity, exec);
 	}

 	auto req = std::make_shared<Get3DBox>();
 	req->reset(this->_bind_entity.lock()->entityID(), this->_bind_entity.lock()->entityID());
-	auto rst = map->execute<Get3DBox, Box3DDesc>(req);
+	auto rst = WsRequest<Get3DBox, Box3DDesc>::impl(this->_bind_entity, req);
 	if (rst.size()) {
 		// 保存当前命令
 		this->_current_cmd = in;
@ -45,7 +45,7 @@ void SurfaceMotionPlugin::execute(std::shared_ptr<Immediate> map,
 	out << exec_result;
 }

-void SurfaceMotionPlugin::execute(std::shared_ptr<Immediate> map,
+void SurfaceMotionPlugin::execute(
 	std::shared_ptr<const StrightLineMotion> in, QList<std::shared_ptr<RespondDefault>>& out)
 {
 	auto exec_result = std::make_shared<RespondDefault>();
@ -54,13 +54,13 @@ void SurfaceMotionPlugin::execute(std::shared_ptr<Immediate> map,
 		auto exec = std::make_shared<MotionDeduceRequest>();
 		exec->reset(in->targetEntity(), in->sourceEntity());
 		exec->_target_time = _current_cmd->startTimepoint();
-		map->execute(exec);
+		this->query(this->_bind_entity, exec);
 	}

 	// 提取起始机动状态
 	auto req = std::make_shared<Get3DBox>();
 	req->reset(this->_bind_entity.lock()->entityID(), this->_bind_entity.lock()->entityID());
-	auto rst = map->execute<Get3DBox, Box3DDesc>(req);
+	auto rst = WsRequest<Get3DBox, Box3DDesc>::impl(this->_bind_entity, req);
 	if (rst.size()) {
 		// 保存当前命令
 		this->_current_cmd = in;
@ -79,21 +79,21 @@ void SurfaceMotionPlugin::execute(std::shared_ptr<Immediate> map,
 }

 #include <QMatrix4x4>
-void SurfaceMotionPlugin::execute(std::shared_ptr<Immediate> map,
+void SurfaceMotionPlugin::execute(
 	std::shared_ptr<const SyncRequest> in, QList<std::shared_ptr<RespondDefault>>& out)
 {
 	auto reqs = std::make_shared<MotionDeduceRequest>();
 	reqs->reset(in->targetEntity(), in->sourceEntity());
 	reqs->_target_time = in->_time_current;

-	for (auto rst : map->execute(reqs)) {
+	for (auto rst : this->query(this->_bind_entity, reqs)) {
 		auto conv = std::dynamic_pointer_cast<RespondDefault>(rst);
 		if (conv) out << conv;
 	}
 }

 #include <cmath>
-void SurfaceMotionPlugin::execute(std::shared_ptr<Immediate> map,
+void SurfaceMotionPlugin::execute(
 	std::shared_ptr<const MotionDeduceRequest> in, QList<std::shared_ptr<RespondDefault>>& out)
 {
 	auto rst = std::make_shared<RespondDefault>();
@ -126,11 +126,11 @@ void SurfaceMotionPlugin::execute(std::shared_ptr<Immediate> map,

 		auto setpos = std::make_shared<Set3DBoxLLAPos>();
 		setpos->_lla_pos = deduce_lla;
-		map->execute(setpos);
+		this->query(this->_bind_entity, setpos);

 		auto setpsr = std::make_shared<Set3DBoxPosture>();
 		setpsr->_posture_d3._azimuth_deg = azimuth_self;
-		map->execute(setpsr);
+		this->query(this->_bind_entity, setpsr);

 		rst->_success_mark = true;
 	}
@ -142,7 +142,7 @@ void SurfaceMotionPlugin::execute(std::shared_ptr<Immediate> map,
 	out << rst;
 }

-std::shared_ptr<WsComponent> SurfaceMotionPlugin::defaultNew() const
+std::shared_ptr<Serializable> SurfaceMotionPlugin::newDefault() const
 {
 	return std::make_shared<SurfaceMotionPlugin>();
 }
--- a/ComponentBasic/SurfaceMotion.h
+++ b/ComponentBasic/SurfaceMotion.h
@ -1,16 +1,21 @@
 #pragma once
 #include <motion_access.h>
 #include "componentbasic.h"
+#include <visiblecube_access.h>
+

 /// <summary>
 /// 水面平台机动组件
 /// </summary>
-class COMPONENTBASIC_EXPORT SurfaceMotionPlugin : public ProcList<
+class COMPONENTBASIC_EXPORT SurfaceMotionPlugin : 
+public RespondRoute<
 	WsRespond<HorizontalArcMotion, RespondDefault>,
 	WsRespond<StrightLineMotion, RespondDefault>,
 	WsRespond<MotionDeduceRequest, RespondDefault>,
-	WsRespond<SyncRequest, RespondDefault>
->{
+	WsRespond<SyncRequest, RespondDefault>>,
+public RequestRoute<
+	WsRequest<Get3DBox, Box3DDesc>>
+{
 private:
 	std::weak_ptr<WsEntity> _bind_entity;
 	std::shared_ptr<const PlatformMotionCommand> _current_cmd = nullptr;
@ -21,12 +26,12 @@ public:
 	SurfaceMotionPlugin();

 	// 通过 ProcList 继承
-	void execute(std::shared_ptr<Immediate> map, std::shared_ptr<const HorizontalArcMotion> in, QList<std::shared_ptr<RespondDefault>>& out) override;
-	void execute(std::shared_ptr<Immediate> map, std::shared_ptr<const StrightLineMotion> in, QList<std::shared_ptr<RespondDefault>>& out) override;
-	void execute(std::shared_ptr<Immediate> map, std::shared_ptr<const MotionDeduceRequest> in, QList<std::shared_ptr<RespondDefault>>& out) override;
-	void execute(std::shared_ptr<Immediate> map, std::shared_ptr<const SyncRequest> in, QList<std::shared_ptr<RespondDefault>>& out) override;
+	void execute(std::shared_ptr<const HorizontalArcMotion> in, QList<std::shared_ptr<RespondDefault>>& out) override;
+	void execute(std::shared_ptr<const StrightLineMotion> in, QList<std::shared_ptr<RespondDefault>>& out) override;
+	void execute(std::shared_ptr<const MotionDeduceRequest> in, QList<std::shared_ptr<RespondDefault>>& out) override;
+	void execute(std::shared_ptr<const SyncRequest> in, QList<std::shared_ptr<RespondDefault>>& out) override;

-	std::shared_ptr<WsComponent> defaultNew() const override;
+	std::shared_ptr<Serializable> newDefault() const override;
 	void bindEntity(std::weak_ptr<WsEntity> host) override;
 	QString name() const override;

--- a/ComponentBasic/VisibleCube.cpp
+++ b/ComponentBasic/VisibleCube.cpp
@ -31,7 +31,7 @@ void VisibleCubePlugin::saveTo(QJsonObject& obj) const {
 	DOUBLE_SAVE(_self_posture._roll_deg);
 }

-std::shared_ptr<WsComponent> VisibleCubePlugin::defaultNew() const {
+std::shared_ptr<Serializable> VisibleCubePlugin::newDefault() const {
 	auto copy = std::make_shared<VisibleCubePlugin>();
 	copy->_bind_entity = _bind_entity;
 	copy->_self_d3 = _self_d3;
@ -49,7 +49,7 @@ QString VisibleCubePlugin::name() const {
 	return NAME(VisibleCubePlugin);
 }

-void VisibleCubePlugin::execute(std::shared_ptr<Immediate> map, std::shared_ptr<const Get3DBox> in, QList<std::shared_ptr<Box3DDesc>>& out)
+void VisibleCubePlugin::execute(std::shared_ptr<const Get3DBox> in, QList<std::shared_ptr<Box3DDesc>>& out)
 {
 	auto ins = std::make_shared<Box3DDesc>();
 	ins->_lla_pos = _self_lla;
@ -59,7 +59,7 @@ void VisibleCubePlugin::execute(std::shared_ptr<Immediate> map, std::shared_ptr<
 	out << ins;
 }

-void VisibleCubePlugin::execute(std::shared_ptr<Immediate> map, std::shared_ptr<const Set3DBoxD3Data> in, QList<std::shared_ptr<RespondDefault>>& out)
+void VisibleCubePlugin::execute(std::shared_ptr<const Set3DBoxD3Data> in, QList<std::shared_ptr<RespondDefault>>& out)
 {
 	auto resp = std::make_shared<RespondDefault>();
 	resp->reset(in->targetEntity(), in->sourceEntity());
@ -69,7 +69,7 @@ void VisibleCubePlugin::execute(std::shared_ptr<Immediate> map, std::shared_ptr<
 	out << resp;
 }

-void VisibleCubePlugin::execute(std::shared_ptr<Immediate> map, std::shared_ptr<const Set3DBoxLLAPos> in, QList<std::shared_ptr<RespondDefault>>& out)
+void VisibleCubePlugin::execute(std::shared_ptr<const Set3DBoxLLAPos> in, QList<std::shared_ptr<RespondDefault>>& out)
 {
 	auto resp = std::make_shared<RespondDefault>();
 	resp->reset(in->targetEntity(), in->sourceEntity());
@ -79,7 +79,7 @@ void VisibleCubePlugin::execute(std::shared_ptr<Immediate> map, std::shared_ptr<
 	out << resp;
 }

-void VisibleCubePlugin::execute(std::shared_ptr<Immediate> map, std::shared_ptr<const Set3DBoxPosture> in, QList<std::shared_ptr<RespondDefault>>& out)
+void VisibleCubePlugin::execute(std::shared_ptr<const Set3DBoxPosture> in, QList<std::shared_ptr<RespondDefault>>& out)
 {
 	auto resp = std::make_shared<RespondDefault>();
 	resp->reset(in->targetEntity(), in->sourceEntity());
--- a/ComponentBasic/VisibleCube.h
+++ b/ComponentBasic/VisibleCube.h
@ -2,16 +2,18 @@
 #include "componentbasic.h"
 #include <messagebasic.h>
 #include <QVariant>
+#include <visiblecube_access.h>

 /// <summary>
 /// 可视化3d体积盒
 /// </summary>
-class COMPONENTBASIC_EXPORT VisibleCubePlugin : public ProcList<
+class COMPONENTBASIC_EXPORT VisibleCubePlugin : 
+public RespondRoute<
 	WsRespond<Get3DBox, Box3DDesc>,
 	WsRespond<Set3DBoxD3Data, RespondDefault>,
 	WsRespond<Set3DBoxLLAPos, RespondDefault>,
-	WsRespond<Set3DBoxPosture, RespondDefault>
->
+	WsRespond<Set3DBoxPosture, RespondDefault>>,
+public RequestRoute<>
 {
 public:
 	std::weak_ptr<WsEntity> _bind_entity;
@ -26,13 +28,13 @@ public:
 	void bindEntity(std::weak_ptr<WsEntity> ins) override;
 	QString name() const override;

-	void execute(std::shared_ptr<Immediate> map, std::shared_ptr<const Get3DBox> in, QList<std::shared_ptr<Box3DDesc>>& out) override;
+	void execute(std::shared_ptr<const Get3DBox> in, QList<std::shared_ptr<Box3DDesc>>& out) override;
 	
-	void execute(std::shared_ptr<Immediate> map, std::shared_ptr<const Set3DBoxD3Data> in, QList<std::shared_ptr<RespondDefault>>& out) override;
-	void execute(std::shared_ptr<Immediate> map, std::shared_ptr<const Set3DBoxLLAPos> in, QList<std::shared_ptr<RespondDefault>>& out) override;
-	void execute(std::shared_ptr<Immediate> map, std::shared_ptr<const Set3DBoxPosture> in, QList<std::shared_ptr<RespondDefault>>& out) override;
+	void execute(std::shared_ptr<const Set3DBoxD3Data> in, QList<std::shared_ptr<RespondDefault>>& out) override;
+	void execute(std::shared_ptr<const Set3DBoxLLAPos> in, QList<std::shared_ptr<RespondDefault>>& out) override;
+	void execute(std::shared_ptr<const Set3DBoxPosture> in, QList<std::shared_ptr<RespondDefault>>& out) override;

-	std::shared_ptr<WsComponent> defaultNew() const override;
+	std::shared_ptr<Serializable> newDefault() const override;
 	void recoveryFrom(const QJsonObject& obj) override;
 	void saveTo(QJsonObject& obj) const override;
 };
--- a/ComponentBasic/componentbasic.h
+++ b/ComponentBasic/componentbasic.h
@ -5,7 +5,7 @@
 #include <QHash>

 /// <summary>
-/// ÏûÏ¢´¦Àíµ¥Ôª»ùÀà
+/// 消息响应处理单元基类
 /// </summary>
 /// <typeparam name="MsgA">输入类型</typeparam>
 /// <typeparam name="MsgB">输出类型</typeparam>
@ -28,64 +28,176 @@ public:
 	/// </summary>
 	/// <param name="in"></param>
 	/// <param name="out"></param>
-	virtual void execute(std::shared_ptr<Immediate> map, std::shared_ptr<const MsgA> in, QList<std::shared_ptr<MsgB>>& out) = 0;
+	virtual void execute(std::shared_ptr<const MsgA> in, QList<std::shared_ptr<MsgB>>& out) = 0;
 	/// <summary>
 	/// WsRespond构造函数
 	/// </summary>
 	/// <param name="map">注册函数</param>
 	explicit WsRespond(QHash<WsRespondSignatureType, WsRespondEntry>& map) {
-		WsRespondEntry ins = [=](std::shared_ptr<Immediate> map, std::shared_ptr<const WsMessage> in, QList<std::shared_ptr<WsMessage>>& out) {
+		WsRespondEntry ins = [=](std::shared_ptr<const WsMessage> in, QList<std::shared_ptr<WsMessage>>& out) {
 			QList<std::shared_ptr<MsgB>> o_ptrs;
-			this->execute(map, std::static_pointer_cast<const MsgA>(in), o_ptrs);
+			this->execute(std::static_pointer_cast<const MsgA>(in), o_ptrs);
 			std::transform(o_ptrs.begin(), o_ptrs.end(), std::back_inserter(out),
-				[](std::shared_ptr<MsgB> v) { return std::static_pointer_cast<WsMessage>(v); });
+				[](std::shared_ptr<MsgB> v) {
+					return std::static_pointer_cast<WsMessage>(v);
+				});
 			};
 		map[SelfType::signature()] = ins;
 	}
 };


-template <typename... ProcSigs>struct _ProcRoute_;
-template <> struct COMPONENTBASIC_EXPORT _ProcRoute_<>
-{
+
+template <typename... RespSigs> struct _RespondRoute;
+/// <summary>
+/// 响应路由数据基类
+/// </summary>
+template <> struct COMPONENTBASIC_EXPORT _RespondRoute<> {
 	QHash<WsRespondSignatureType, WsRespondEntry> _execute_map;
-
-	_ProcRoute_() = default;
+	_RespondRoute() = default;
 };
-template <typename ProcSig, typename... ProcSigs>
-struct _ProcRoute_<ProcSig, ProcSigs...> : public _ProcRoute_<ProcSigs...>, public ProcSig
-{
-	_ProcRoute_() : _ProcRoute_<ProcSigs...>(), ProcSig(_ProcRoute_<>::_execute_map) {}
+/// <summary>
+/// 消息响应路由综合基类
+/// </summary>
+/// <typeparam name="RespSig">类型</typeparam>
+/// <typeparam name="...RespSigs">其余类型列表</typeparam>
+template <typename RespSig, typename... RespSigs>
+struct _RespondRoute<RespSig, RespSigs...> : public _RespondRoute<RespSigs...>, public RespSig {
+	_RespondRoute() : _RespondRoute<RespSigs...>(), RespSig(_RespondRoute<>::_execute_map) {}
 };

-template <typename... Procs>
-struct ProcList : public _ProcRoute_<Procs...>, public WsComponent
-{
-	using SuperType = ProcList<Procs...>;

-	ProcList() : _ProcRoute_<Procs...>() {}
+
+/// <summary>
+/// 消息响应列表
+/// </summary>
+/// <typeparam name="...Resp"></typeparam>
+template <typename... Resp>
+struct RespondRoute : virtual public WsComponent, public _RespondRoute<Resp...> {
+	RespondRoute() : _RespondRoute<Resp...>() {}

 	// 通过 WsComponent 继承
-	QList<WsRespondSignatureType> signatureTypes() const override
+	virtual QList<WsRespondSignatureType> respondSignatures() const
 	{
-		return _ProcRoute_<>::_execute_map.keys();
+		return _RespondRoute<>::_execute_map.keys();
 	}
-	QList<WsRespondEntry> getEntryWithSignature(const WsRespondSignatureType& t) const override
+	virtual QList<WsRespondEntry> getRespondWithSignature(const WsRespondSignatureType& t) const
 	{
 		QList<WsRespondEntry> list;
-		for (auto key : _ProcRoute_<>::_execute_map.keys()) {
-			if (key == t)
-				list.append(_ProcRoute_<>::_execute_map[key]);
-		}
+		if (_RespondRoute<>::_execute_map.contains(t))
+			list << _RespondRoute<>::_execute_map[t];
 		return list;
 	}
-	QList<WsRespondEntry> getEntrysWithInType(const QString& msg_type) const override
+	virtual QList<WsRespondEntry> getRespondWithInType(const QString& msg_type) const
 	{
 		QList<WsRespondEntry> list;
-		for (auto key : _ProcRoute_<>::_execute_map.keys()) {
+		for (auto key : _RespondRoute<>::_execute_map.keys()) {
 			if (key.first == msg_type)
-				list.append(_ProcRoute_<>::_execute_map[key]);
+				list.append(_RespondRoute<>::_execute_map[key]);
 		}
 		return list;
 	}
 };
+
+
+
+
+
+// ===========================================================
+/// <summary>
+/// Request发送接口
+/// </summary>
+/// <typeparam name="MsgA"></typeparam>
+/// <typeparam name="MsgB"></typeparam>
+template<typename MsgA, typename MsgB> class WsRequest {
+public:
+	using SelfType = WsRequest<MsgA, MsgB>;
+
+	virtual ~WsRequest() = default;
+	/// <summary>
+	/// Request的类型签名
+	/// </summary>
+	/// <returns></returns>
+	static WsRequestSignatureType signature()
+	{
+		return std::make_pair<QString, QString>(MsgA().topicString(), MsgB().topicString());
+	}
+
+	/// <summary>
+	/// 子类中实际处理函数
+	/// </summary>
+	/// <param name="in"></param>
+	/// <param name="out"></param>
+	static void request(std::weak_ptr<WsEntity> e, std::shared_ptr<const MsgA> in, QList<std::shared_ptr<MsgB>>& out) {
+		auto entries = e.lock()->getRespondWithSignature(SelfType::signature());
+
+		QList<std::shared_ptr<WsMessage>> o_list;
+		for (auto func_it : entries) {
+			func_it(in, o_list);
+		}
+		for (auto msg : o_list) {
+			auto conv = std::dynamic_pointer_cast<MsgB>(msg);
+			if (conv) out << conv;
+		}
+	}
+
+	static QList<std::shared_ptr<MsgB>> impl(std::weak_ptr<WsEntity> e, std::shared_ptr<const MsgA> in) {
+		QList<std::shared_ptr<MsgB>> out;
+		WsRequest<MsgA, MsgB>::request(e, in, out);
+		return out;
+	}
+
+	/// <summary>
+	/// WsRequest构造函数
+	/// </summary>
+	/// <param name="request_list">Request类型列表</param>
+	explicit WsRequest(QList<WsRequestSignatureType>& request_list) {
+		request_list << SelfType::signature();
+	}
+};
+
+
+
+template<typename... ReqsSigs> struct _RequestRoute;
+/// <summary>
+/// 请求发送数据基类
+/// </summary>
+template<> struct COMPONENTBASIC_EXPORT _RequestRoute<> {
+	QList<WsRequestSignatureType> _request_list;
+	_RequestRoute() = default;
+
+	QList<std::shared_ptr<WsMessage>> query(std::weak_ptr<WsEntity> e, std::shared_ptr<const WsMessage> in) {
+		auto binde = e.lock();
+		auto entries = binde->getRespondWithInType(in->topicString());
+
+		QList<std::shared_ptr<WsMessage>> out;
+		for (auto func_it : entries) {
+			func_it(in, out);
+		}
+		return out;
+	}
+};
+/// <summary>
+/// 消息发送综合基类
+/// </summary>
+/// <typeparam name="ReqsSig"></typeparam>
+/// <typeparam name="...ReqsSigs"></typeparam>
+template<typename ReqsSig, typename... ReqsSigs>
+struct _RequestRoute<ReqsSig, ReqsSigs...> : public _RequestRoute<ReqsSigs...>, public ReqsSig {
+	_RequestRoute() : _RequestRoute<ReqsSigs...>(), ReqsSig(_RequestRoute<>::_request_list) {}
+};
+
+
+
+/// <summary>
+/// 消息发送注册基类
+/// </summary>
+/// <typeparam name="...Reqs"></typeparam>
+template<typename... Reqs>
+struct RequestRoute : virtual public WsComponent, public _RequestRoute<Reqs...> {
+	RequestRoute() : _RequestRoute<Reqs...>() {}
+	virtual QList<WsRequestSignatureType> requestSignatures() const {
+		return _RequestRoute<>::_request_list;
+	}
+};
+