第242章　Scene Engine｜场景引擎

242.1 场景引擎的定义

在个体人工智能系统中，认知并不是脱离环境独立发生的。

同一个对象，在不同环境、目标、状态和历史条件下，可能具有完全不同的意义。

因此，系统必须回答一个基础问题：

当前正在什么场景中？

场景引擎就是负责建立、维护、更新和运行场景模型的核心机制。

定义：

$SceneEngine=Execute(Scene)SceneEngine = Execute(Scene)$

即：

场景引擎是使场景结构能够被识别、构建、激活、切换、更新和运行的认知引擎。

它不是简单的场景分类器。

场景分类只是场景引擎的一项能力。

场景引擎真正处理的是：

$Scene=Actor+Environment+Object+Goal+Action+State+ContextScene = Actor + Environment + Object + Goal + Action + State + Context$

因此：

$SceneEngine=SceneRecognition+SceneConstruction+SceneActivation+SceneTransition+SceneUpdateSceneEngine = SceneRecognition + SceneConstruction + SceneActivation + SceneTransition + SceneUpdate$

242.2 为什么需要场景引擎

如果没有场景结构，系统只能看到孤立的信息。

例如：

Camera
Person
Table
Cup
Phone

这些只是对象。

系统还不知道：

人在哪里；
人正在做什么；
当前目的是什么；
哪些对象存在关系；
当前处于什么状态；
下一步应该关注什么。

加入场景之后：

Scene
│
├── Actor
├── Environment
├── Objects
├── Relations
├── Goal
├── Actions
├── States
└── Context

系统才开始形成：

“当前发生了什么。”

因此：

$Object≠SceneObject \neq Scene$

对象是场景中的认知实体。

而：

$Scene=Structured ContextScene = Structured\ Context$

场景则是对象、关系、状态、目标和环境形成的整体结构。

242.3 场景不是地点

“场景”不能简单理解成物理地点。

例如：

深圳办公室

可以是一个地点。

但：

深圳办公室中的客户接待场景

才是一个完整场景。

同一个地点可以产生不同场景：

办公室
│
├── 工作场景
├── 会议场景
├── 接待场景
├── 培训场景
└── 休息场景

因此：

$Location≠SceneLocation \neq Scene$

场景由：

$Environment+Actor+Object+Goal+State+ActionEnvironment + Actor + Object + Goal + State + Action$

共同构成。

242.4 场景结构

可以定义：

$S=(E,A,O,R,G,Ac,St,C)S=(E,A,O,R,G,Ac,St,C)$

其中：

$EE$ ：Environment，环境
$AA$ ：Actor，参与者
$OO$ ：Object，对象
$RR$ ：Relation，关系
$GG$ ：Goal，目标
$AcAc$ ：Action，动作
$StSt$ ：State，状态
$CC$ ：Context，上下文

因此：

$Scene=(E,A,O,R,G,Ac,St,C)Scene = (E,A,O,R,G,Ac,St,C)$

场景不是单一数据对象，而是一个结构化认知状态。

242.5 场景识别

场景引擎首先需要回答：

当前输入属于什么场景？

定义：

$SceneRecognition=f(Perception,Memory,Knowledge,Context)SceneRecognition = f(Perception,Memory,Knowledge,Context)$

例如：

Perception
   ↓
Objects
   ↓
Relations
   ↓
States
   ↓
Goal
   ↓
Scene Recognition

场景识别并不是单纯根据一个对象进行判断。

例如：

Camera + Person

无法直接确定场景。

但：

Person
+ Meeting Table
+ Multiple People
+ Presentation Screen
+ Conversation

就可能形成：

$MeetingSceneMeetingScene$

因此场景识别依赖：

$Object+Relation+State+ContextObject + Relation + State + Context$

242.6 场景构建

识别只是第一步。

场景引擎还必须构建场景模型：

$SceneConstruction=Build(Elements,Objects,Relations,States,Goals)SceneConstruction = Build(Elements,Objects,Relations,States,Goals)$

过程可以表示为：

Elements
   ↓
Objects
   ↓
Relations
   ↓
States
   ↓
Goal
   ↓
Scene

这与 EOM 理论存在直接关系。

$Element→Object→Relation→SceneElement \rightarrow Object \rightarrow Relation \rightarrow Scene$

因此场景不是预先存在的固定标签。

它可以由认知元素动态组织出来。

242.7 场景激活

系统并不需要同时运行所有场景。

它需要确定：

当前哪个场景处于活动状态？

定义：

$ActiveScenet=Select(SceneSet,Contextt)ActiveScene_t = Select(SceneSet,Context_t)$

例如系统记忆中可能存在：

Work Scene
Shopping Scene
Learning Scene
Meeting Scene
Travel Scene
Writing Scene

但当前只有：

Learning Scene

处于 Active 状态。

因此：

$Sceneactive=LearningSceneScene_{active}=LearningScene$

场景激活会直接影响：

注意力；
感知范围；
知识检索；
方法选择；
行为选择；
输出方式。

242.8 场景状态

场景不是静态标签，而是动态状态。

可以定义：

$SceneState∈{Created,Active,Suspended,Changing,Completed,Archived}SceneState \in \{ Created, Active, Suspended, Changing, Completed, Archived \}$

典型状态：

CREATED
   ↓
ACTIVE
   ↓
CHANGING
   ↓
ACTIVE
   ↓
COMPLETED

多个场景还可以同时存在：

Scene A → Active
Scene B → Suspended
Scene C → Background

这意味着个体人工智能可以拥有：

场景空间，而不仅仅是单一当前场景。

242.9 场景上下文

场景必须携带上下文。

定义：

$Context=Scene+State+History+Goal+EnvironmentContext = Scene + State + History + Goal + Environment$

例如：

同一个对象：

“订单”

在不同场景中的意义不同。

采购场景
→ 订单 = 采购订单

销售场景
→ 订单 = 销售订单

物流场景
→ 订单 = 配送对象

售后场景
→ 订单 = 服务依据

因此：

$Meaning(Object)=f(Object,Scene,Context)Meaning(Object) = f(Object,Scene,Context)$

这意味着：

对象意义不是完全固定的，而具有场景依赖性。

242.10 场景与知识

场景引擎并不等于知识库。

知识回答：

系统知道什么。

场景回答：

当前这些知识处于什么情境中。

例如：

Knowledge
│
├── Product
├── Customer
├── Price
├── Order
└── Delivery

进入不同场景之后：

Sales Scene
→ Product + Customer + Price + Order

Logistics Scene
→ Order + Delivery

After-Sales Scene
→ Customer + Order + Service

因此：

$Knowledge→Scene→ContextualKnowledgeKnowledge \rightarrow Scene \rightarrow ContextualKnowledge$

场景使知识获得上下文。

242.11 场景与记忆

场景也是记忆组织的重要索引。

定义：

$MemoryRetrieval=f(Query,Scene,Context)MemoryRetrieval = f(Query,Scene,Context)$

同样的问题：

“这个客户之前买过什么？”

如果当前处于：

Sales Scene

系统可能优先调用销售历史。

如果处于：

After-Sales Scene

则可能优先调用：

订单记录；
售后记录；
产品信息；
服务记录。

因此：

$Scene→MemoryActivationScene \rightarrow MemoryActivation$

场景可以成为记忆检索的重要条件。

242.12 场景与感知控制

第233章定义了感知控制器：

控制系统应该感知什么。

场景引擎则提供：

当前场景需要关注什么。

因此：

$SceneEngine→PerceptionControllerSceneEngine \rightarrow PerceptionController$

例如：

Meeting Scene
   ↓
关注
   ├── Participants
   ├── Speech
   ├── Presentation
   └── Decisions

而：

Driving Scene
   ↓
关注
   ├── Road
   ├── Traffic
   ├── Signals
   └── Obstacles

所以：

$Scene→Attention→PerceptionScene \rightarrow Attention \rightarrow Perception$

场景能够改变感知重点。

242.13 场景切换

个体人工智能不可能永远停留在一个场景中。

因此必须支持：

$SceneA→SceneBScene_A \rightarrow Scene_B$

例如：

Learning
   ↓
User Request
   ↓
Conversation
   ↓
Task Execution

场景切换可以由以下因素触发：

新输入；
新目标；
环境变化；
状态变化；
行为完成；
用户意图变化；
时间变化；
外部事件。

定义：

$Transition(SA,SB∣C)Transition(S_A,S_B|C)$

其中 $CC$ 为触发条件。

242.14 场景切换不是场景删除

当从：

$SceneA→SceneBScene_A \rightarrow Scene_B$

并不意味着：

$SceneA=DeleteScene_A = Delete$

更合理的是：

$SceneA→SuspendedScene_A \rightarrow Suspended$

然后：

$SceneB→ActiveScene_B \rightarrow Active$

形成：

Scene A
   ↓
SUSPENDED
   ↓
Background Memory

Scene B
   ↓
ACTIVE

因此场景具有连续性。

这使系统能够在场景之间恢复上下文。

242.15 场景共同性

第234章提出：

$SceneCommonality=Shared(Entity,Attribute,Relation,State,Rule)SceneCommonality = Shared(Entity,Attribute,Relation,State,Rule)$

场景引擎需要利用这种共同性。

例如：

Sales Scene
Customer + Product + Order

After-Sales Scene
Customer + Product + Order

两个场景存在共同结构：

$CAB=SA∩SBC_{AB}=S_A\cap S_B$

因此可以共享：

对象；
属性；
关系；
状态；
知识；
记忆。

这避免形成：

Scene A Knowledge Island

Scene B Knowledge Island

Scene C Knowledge Island

而形成：

          Common Knowledge
          /      |      \
     Scene A  Scene B  Scene C

242.16 场景差异

场景引擎不仅需要知道共同部分，还必须识别差异。

定义：

$SceneDifference(SA,SB)=SA-SBSceneDifference(S_A,S_B) = S_A-S_B$

或者：

$DAB=Features(SA)ΔFeatures(SB)D_{AB} = Features(S_A)\Delta Features(S_B)$

其中 $Δ\Delta$ 表示差异集合。

场景共同性负责：

知识复用。

场景差异负责：

保持场景独立性。

因此：

$SceneUnderstanding=Commonality+DifferenceSceneUnderstanding = Commonality + Difference$

242.17 场景嵌套

现实世界中的场景经常不是平面的。

一个场景可以包含子场景：

Business Scene
│
├── Meeting Scene
│   ├── Presentation
│   └── Discussion
│
├── Negotiation Scene
│
└── Contract Scene

因此：

$Scene⊃SubSceneScene \supset SubScene$

可以定义：

$SceneHierarchy={S1,S2,…,Sn}SceneHierarchy = \{S_1,S_2,…,S_n\}$

并建立：

$ParentScene→ChildSceneParentScene \rightarrow ChildScene$

这使场景模型具有层次结构。

242.18 场景中的时间

场景不仅具有空间和对象结构，还具有时间。

定义：

$ScenetScene_t$

因此：

$Scenet+1=Update(Scenet,Eventt)Scene_{t+1} = Update(Scene_t,Event_t)$

例如：

订单创建
   ↓
订单支付
   ↓
订单生产
   ↓
订单发货
   ↓
订单完成

实际上是同一个业务对象在不同时间状态下形成连续场景。

因此：

$Scene=Structure+State+TimeScene = Structure + State + Time$

242.19 场景事件

场景变化通常由事件触发。

定义：

$Event→SceneUpdateEvent \rightarrow SceneUpdate$

例如：

UserInput
     ↓
Event
     ↓
Scene Change

或者：

Device Signal
     ↓
Event
     ↓
Scene Update

场景引擎因此需要维护：

$Event→State→SceneEvent \rightarrow State \rightarrow Scene$

这使场景成为动态认知结构。

242.20 场景预测

当场景具有历史信息之后，系统可以进一步预测场景变化。

定义：

$P(Scenet+1∣Scenet,History,Event)P(Scene_{t+1}|Scene_t,History,Event)$

例如：

当前：
订单已付款

预测：
订单进入生产阶段

场景预测可以服务于：

行为规划；
方法选择；
资源准备；
风险判断；
信息检索；
主动感知。

因此：

$SceneEngine→ScenePredictionSceneEngine \rightarrow ScenePrediction$

使场景引擎从“识别当前”扩展到“预测下一状态”。

242.21 场景与决策

决策不能脱离场景。

定义：

$Decision=f(Scene,Goal,Knowledge,State)Decision = f(Scene,Goal,Knowledge,State)$

同一个动作在不同场景下可能产生不同决策。

例如：

Action = SendMessage

在：

Customer Service Scene

与：

Internal Discussion Scene

中的意义不同。

因此：

$Decision≠SceneIndependentDecision \neq SceneIndependent$

更准确地说：

$Decision=ContextualDecisionDecision = ContextualDecision$

场景为决策提供上下文边界。

242.22 场景与方法

方法控制器负责：

选择怎么做。

但方法选择同样依赖场景。

定义：

$Method∗=argmaxm∈MScore(m∣Scene,Goal,Object)Method^* = argmax_{m\in M} Score(m|Scene,Goal,Object)$

因此：

$Scene→MethodController→MethodScene \rightarrow MethodController \rightarrow Method$

同一个目标：

获取客户信息

在不同场景下可能使用不同方法：

CRM Scene
→ Database Retrieval

Conversation Scene
→ Dialogue Extraction

Web Research Scene
→ Information Retrieval

所以：

$Method=f(Scene,Goal,Object)Method = f(Scene,Goal,Object)$

242.23 场景与行为

行为同样具有场景依赖。

$Behavior=f(Scene,Goal,Decision)Behavior = f(Scene,Goal,Decision)$

例如：

Meeting Scene
→ Listen
→ Speak
→ Record
→ Summarize

而：

Learning Scene
→ Read
→ Compare
→ Practice
→ Evaluate

因此：

$Scene→BehaviorScene \rightarrow Behavior$

场景决定行为的适用范围。

242.24 场景引擎内部结构

可以将 Scene Engine 构造成：

                 Scene Engine
                      │
       ┌──────────────┼──────────────┐
       ↓              ↓              ↓
 Scene Recognition  Scene Builder  Scene Memory
       │              │              │
       └──────────────┼──────────────┘
                      ↓
                Scene Model
                      ↓
              Scene Activation
                      ↓
              Scene State Manager
                      ↓
              Scene Transition
                      ↓
                Scene Update
                      ↓
               Scene Prediction

核心模块包括：

Scene Recognition
Scene Builder
Scene Model
Scene Memory
Scene Activation
Scene State Manager
Scene Transition
Scene Update
Scene Prediction

242.25 场景引擎的数据结构

一个基础场景对象可以抽象为：

$SceneObject={ID,Type,Actors,Environment,Objects,Relations,Goal,Actions,States,Context,History,Timestamp,Confidence}SceneObject= \{ ID, Type, Actors, Environment, Objects, Relations, Goal, Actions, States, Context, History, Timestamp, Confidence \}$

其中：

$Confidence(Scene)∈[0,1]Confidence(Scene)\in[0,1]$

这意味着系统不仅知道：

“当前是什么场景。”

还知道：

“我有多大把握认为当前是这个场景。”

242.26 场景不确定性

现实环境可能同时符合多个场景。

例如：

Meeting Scene: 0.72
Training Scene: 0.61
Discussion Scene: 0.54

系统不一定必须立即选择唯一场景。

可以维护：

$P(Si∣Input,Context)P(S_i|Input,Context)$

形成场景候选集合：

$SceneCandidates={S1,S2,…,Sn}SceneCandidates = \{S_1,S_2,…,S_n\}$

然后根据新的感知信息逐步收敛。

因此：

$Perception→SceneHypothesis→Verification→ActiveScenePerception \rightarrow SceneHypothesis \rightarrow Verification \rightarrow ActiveScene$

242.27 场景引擎与认知引擎

第241章定义：

$CognitiveEngine=Execute(Cognition)CognitiveEngine = Execute(Cognition)$

第242章进一步定义：

$SceneEngine=Execute(Scene)SceneEngine = Execute(Scene)$

两者不是竞争关系。

而是：

$CognitiveEngine⊃SceneEngineCognitiveEngine \supset SceneEngine$

或者在工程实现上：

Cognitive Engine
│
├── Scene Engine
├── Memory Engine
├── Knowledge Engine
├── Reasoning Engine
├── Decision Engine
└── ...

场景引擎是认知引擎中的一个重要专用引擎。

242.28 Scene Engine 与 Scene Controller

必须区分：

$SceneController≠SceneEngineSceneController \neq SceneEngine$

如果未来定义场景控制器，那么：

Scene Controller

回答：

场景应该如何控制？

例如：

是否切换；
切换到哪里；
是否保持；
是否激活；
是否暂停。

而：

Scene Engine

回答：

场景本身如何被识别、构建、维护和运行？

因此：

$Controller=ControlController = Control$ $Engine=ExecuteEngine = Execute$

这与第241章建立的理论边界一致。

242.29 场景引擎与 EOM

EOM：

$Element→Object→MethodElement \rightarrow Object \rightarrow Method$

场景将这些认知结构组织到具体上下文中。

可以扩展为：

$Element→Object→Relation→Scene→Goal→MethodElement \rightarrow Object \rightarrow Relation \rightarrow Scene \rightarrow Goal \rightarrow Method$

进一步进入行为：

$Scene→Method→Behavior→Action→Device→ExecutionScene \rightarrow Method \rightarrow Behavior \rightarrow Action \rightarrow Device \rightarrow Execution$

因此：

Element
   ↓
Object
   ↓
Relation
   ↓
Scene
   ↓
Goal
   ↓
Method
   ↓
Behavior
   ↓
Action
   ↓
Device
   ↓
Execution

场景成为：

认知结构与行动结构之间的重要上下文层。

242.30 场景闭环

场景不是一次识别后永久固定。

完整运行过程为：

Perception
   ↓
Scene Recognition
   ↓
Scene Construction
   ↓
Scene Activation
   ↓
Cognition
   ↓
Decision
   ↓
Behavior
   ↓
Action
   ↓
Execution
   ↓
Environment Change
   ↓
New Perception
   ↓
Scene Update

因此：

$Scenet→Actiont→Environmentt+1→Perceptiont+1→Scenet+1Scene_t \rightarrow Action_t \rightarrow Environment_{t+1} \rightarrow Perception_{t+1} \rightarrow Scene_{t+1}$

这意味着场景本身也是反馈系统。

242.31 场景引擎的核心公式

可以将场景引擎抽象为：

$St=SE(Pt,Mt,Kt,Gt,Ht,Et,Ft−1)S_t = SE(P_t,M_t,K_t,G_t,H_t,E_t,F_{t-1})$

其中：

$PtP_t$ ：当前感知；
$MtM_t$ ：记忆；
$KtK_t$ ：知识；
$GtG_t$ ：目标；
$HtH_t$ ：历史；
$EtE_t$ ：环境；
$Ft−1F_{t-1}$ ：上一轮反馈。

场景更新：

$St+1=Update(St,Pt+1,Eventt+1,Feedbackt)S_{t+1} = Update(S_t,P_{t+1},Event_{t+1},Feedback_t)$

场景切换：

$St→ConditionSt+1S_t \xrightarrow{Condition} S_{t+1}$

场景预测：

$S^t+1=Predict(St,History,Event)\hat S_{t+1} = Predict(S_t,History,Event)$

242.32 场景引擎的核心原则

原则一：场景不是地点

$Location≠SceneLocation \neq Scene$

原则二：场景不是对象集合

$Scene≠{Object1,Object2,…}Scene \neq \{Object_1,Object_2,…\}$

场景必须包含关系、状态、目标和上下文。

原则三：场景不是静态标签

$Scenet≠Scenet+1Scene_t\neq Scene_{t+1}$

场景具有动态性。

原则四：场景决定上下文

$Meaning(Object)=f(Object,Scene,Context)Meaning(Object) = f(Object,Scene,Context)$

原则五：场景影响认知

$Scene→Perception→Memory→Knowledge→DecisionScene \rightarrow Perception \rightarrow Memory \rightarrow Knowledge \rightarrow Decision$

原则六：场景影响行动

$Scene→Method→Behavior→ActionScene \rightarrow Method \rightarrow Behavior \rightarrow Action$

原则七：场景必须允许切换

$SceneA→SceneBScene_A \rightarrow Scene_B$

原则八：场景必须能够更新

$Scenet+1=Update(Scenet,Event)Scene_{t+1} = Update(Scene_t,Event)$

242.33 WSaiOS 场景引擎的完整位置

结合前面的控制器和引擎体系，可以形成：

                 WSaiOS
                    │
          ┌─────────┴─────────┐
          ↓                   ↓
     Cognitive Model      Controllers
          │                   │
          ↓                   ↓
     Cognitive Engine   Cognition Controller
          │                   │
          ├───────────────┐   │
          ↓               ↓   │
     Scene Engine     Memory Engine
          │               │
          └───────┬───────┘
                  ↓
              Cognition
                  ↓
               Decision
                  ↓
           Method Controller
                  ↓
                Method
                  ↓
          Behavior Controller
                  ↓
               Behavior
                  ↓
            Action Controller
                  ↓
                Action
                  ↓
            Device Controller
                  ↓
                Device
                  ↓
          Execution Controller
                  ↓
              Execution
                  ↓
              Executor
                  ↓
             Environment
                  ↓
               Feedback
                  ↓
              Perception

这里的关键关系是：

$SceneEngine→CognitiveEngine→CognitionSceneEngine \rightarrow CognitiveEngine \rightarrow Cognition$

同时：

$Scene→PerceptionScene \rightarrow Perception$

以及：

$Scene→MemoryScene \rightarrow Memory$ $Scene→MethodScene \rightarrow Method$ $Scene→BehaviorScene \rightarrow Behavior$

因此场景实际上横跨整个认知—行动过程。

242.34 场景引擎的理论意义

场景引擎解决的是个体人工智能中的一个核心问题：

知识如何进入具体情境。

没有场景：

$Knowledge→StaticKnowledge \rightarrow Static$

有场景：

$Knowledge→Context→Cognition→DecisionKnowledge \rightarrow Context \rightarrow Cognition \rightarrow Decision$

因此：

$Scene=Contextualization LayerScene = Contextualization\ Layer$

场景使：

对象获得上下文；
知识获得使用环境；
记忆获得检索边界；
方法获得适用条件；
行为获得行动背景；
决策获得现实依据。

242.35 本章结论

Scene Engine 不是简单的“场景识别模块”。

它是个体人工智能中负责：

$Recognition+Construction+Activation+Maintenance+Transition+Update+PredictionRecognition + Construction + Activation + Maintenance + Transition + Update + Prediction$

的场景运行机制。

其核心定义为：

$SceneEngine=Execute(Scene)\boxed{ SceneEngine = Execute(Scene) }$

场景结构可以表示为：

$Scene=Environment+Actor+Object+Relation+Goal+Action+State+Context\boxed{ Scene = Environment + Actor + Object + Relation + Goal + Action + State + Context }$

场景引擎将孤立的：

$Element→ObjectElement \rightarrow Object$

进一步组织成：

$Element→Object→Relation→SceneElement \rightarrow Object \rightarrow Relation \rightarrow Scene$

再连接到：

$Scene→Goal→Method→Behavior→Action→Device→ExecutionScene \rightarrow Goal \rightarrow Method \rightarrow Behavior \rightarrow Action \rightarrow Device \rightarrow Execution$

最终形成：

$Perception→Scene→Cognition→Decision→Behavior→Action→Execution→Feedback→Scenenext\boxed{ Perception \rightarrow Scene \rightarrow Cognition \rightarrow Decision \rightarrow Behavior \rightarrow Action \rightarrow Execution \rightarrow Feedback \rightarrow Scene_{next} }$

因此，场景是个体人工智能连接“对象、知识、记忆、目标、行为与现实环境”的上下文结构，而场景引擎则负责让这种上下文持续运行。

从 WSaiOS 的整体理论来看：

Cognitive Model 定义认知结构，Cognition Controller 控制认知过程，Cognitive Engine 运行认知过程，Scene Engine 则让认知始终处于具体场景之中。

第242章 Scene Engine｜场景引擎

第242章 Scene Engine｜场景引擎

242.1 场景引擎的定义

242.2 为什么需要场景引擎

242.3 场景不是地点

242.4 场景结构

242.5 场景识别

242.6 场景构建

242.7 场景激活

242.8 场景状态

242.9 场景上下文

242.10 场景与知识

242.11 场景与记忆

242.12 场景与感知控制

242.13 场景切换

242.14 场景切换不是场景删除

242.15 场景共同性

242.16 场景差异

242.17 场景嵌套

242.18 场景中的时间

242.19 场景事件

242.20 场景预测

242.21 场景与决策

242.22 场景与方法

242.23 场景与行为

242.24 场景引擎内部结构

242.25 场景引擎的数据结构

242.26 场景不确定性

242.27 场景引擎与认知引擎

242.28 Scene Engine 与 Scene Controller

Scene Controller

Scene Engine

242.29 场景引擎与 EOM

242.30 场景闭环

242.31 场景引擎的核心公式

242.32 场景引擎的核心原则

原则一：场景不是地点

原则二：场景不是对象集合

原则三：场景不是静态标签

原则四：场景决定上下文

原则五：场景影响认知

原则六：场景影响行动

原则七：场景必须允许切换

原则八：场景必须能够更新

242.33 WSaiOS 场景引擎的完整位置

242.34 场景引擎的理论意义

242.35 本章结论