编译成功

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,7 +34,7 @@ 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>();
 }
@@ -24,17 +49,605 @@ QString BehaviorPerformPlugin::name() const
 	return NAME(BehaviorPerformPlugin);
 }
 
-void MapHost::setVariable(const QString& key, std::shared_ptr<TopicData> ins)
+#include <MessageLoader.h>
-{
+MapKernal::MapKernal(std::shared_ptr<MessageLoader> ins)
-	if (_variable_map.contains(key) && _variable_map[key]->topicString() != ins->typeName())
+	: _bind_loader(ins) {
-		throw new UniException("不同数据类型数据绑定同一个名称！");
+	for (auto key : ins->allType())
-	_variable_map[key] = ins;
+		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;
 }

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<
+class COMPONENTBASIC_EXPORT BehaviorPerformPlugin :
-	WsRespond<SyncRequest, RespondDefault>
+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;
 };

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">

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>();
 }

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<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 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;
 };

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());
+			auto enters = item->getRespondWithInType(msg->topicString());
-			for (auto e : enters)
+			for (auto efunc : enters)
-				e(immediate, msg, rets);
+				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();
@@ -119,7 +117,7 @@ void DeduceFramework::execute(std::shared_ptr<Immediate> map,
 			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());
+			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);
@@ -164,7 +162,7 @@ void DeduceFramework::execute(std::shared_ptr<Immediate> map,
 	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();
@@ -258,7 +256,7 @@ void DeduceFramework::execute(std::shared_ptr<Immediate> map,
 	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;

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<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<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<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<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 EntityTotalGet> in, QList<std::shared_ptr<EntityTotalList>>& out) override;
 };

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;
 }

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<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<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<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 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;
 };

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>();
 }

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<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<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<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 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;
 

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());

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<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<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 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;
 };

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;
-
+	_RespondRoute() = default;
-	_ProcRoute_() = default;
 };
-template <typename ProcSig, typename... ProcSigs>
+/// <summary>
-struct _ProcRoute_<ProcSig, ProcSigs...> : public _ProcRoute_<ProcSigs...>, public ProcSig
+/// 消息响应路由综合基类
-{
+/// </summary>
-	_ProcRoute_() : _ProcRoute_<ProcSigs...>(), ProcSig(_ProcRoute_<>::_execute_map) {}
+/// <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 (_RespondRoute<>::_execute_map.contains(t))
-			if (key == t)
+			list << _RespondRoute<>::_execute_map[t];
-				list.append(_ProcRoute_<>::_execute_map[key]);
-		}
 		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;
+	}
+};
+