Add setting option

Reviewed-on: http://git.mrkbear.com/MrKBear/living-together/pulls/52

config/parseSave2Obj.js

@@ -0,0 +1,304 @@
+const PATH = require("path");
+const FS = require("fs");
+const MINIMIST = require("minimist");
+const READLINE = require("readline-sync");
+
+const ARGS = MINIMIST(process.argv.slice(2), {
+    alias: {i: ["input", "save"], o: ["output", "obj"]}
+});
+
+// 获取路径
+const inputFilePath = PATH.resolve(ARGS.i ?? "./save.ltss");
+const outputFilePath = PATH.resolve(ARGS.o ?? "./output.obj");
+
+// 读取文件
+const fileString = FS.readFileSync(inputFilePath);
+console.log("文件读取成功...\r\n");
+
+/**
+ * 引入所需类型
+ * @typedef {import("../source/Model/Archive").IArchiveObject} IArchiveObject
+ * @typedef {import("../source/Model/Clip").IArchiveClip} IArchiveClip
+ */
+
+/**
+ * 解析文件
+ * @type {IArchiveObject}
+ */
+const archive = JSON.parse(fileString);
+console.log("文件解析成功...\r\n");
+
+// 打印全部的剪辑列表
+if (archive.clipPool.length > 0) {
+    console.log("这个存档中存在以下剪辑:");
+}
+archive.clipPool.map((item, index) => {    
+    console.log(" \033[44;30m" + (index + 1) + "\033[40;32m " + item.name + " [" + item.id + "]\033[0m");
+});
+
+/**
+ * 选择剪辑
+ * @type {IArchiveClip}
+ */
+let clip;
+if (archive.clipPool.length <= 0) {
+    console.log("存档中没有剪辑, 退出程序...\r\n");
+    process.exit();
+} else if (archive.clipPool.length === 1) {
+    console.log("\r\n存档中只有一个剪辑, 自动选择...\r\n");
+    clip = archive.clipPool[0];
+} else {
+    console.log("\r\n请选择一个剪辑: ");
+    let userInput = READLINE.question();
+    for (let i = 0; i < archive.clipPool.length; i++) {
+        if ((i + 1) == userInput) {
+            clip = archive.clipPool[i];
+            break;
+        }
+    }
+}
+
+// 选择提示
+if (clip) {
+    console.log("已选择剪辑: " + clip.name + "\r\n");
+} else {
+    console.log("没有选择任何剪辑, 退出程序...\r\n");
+    process.exit();
+}
+
+// 解压缩文件
+console.log("正在还原压缩剪辑记录...\r\n");
+const frames = clip.frames;
+
+/**
+ * @type {Map<string, {name: string, type: string, select?: boolean}}
+ */
+const objectMapper = new Map();
+
+const LastFrameData = "@";
+
+/**
+ * @type {IArchiveClip["frames"]}
+ */
+const F = [];
+frames.forEach((frame) => {
+    /**
+     * @type {IArchiveClip["frames"][number]["commands"]}
+     */
+    const FCS = [];
+    frame.commands.forEach((command) => {
+
+        // 压缩指令
+        const FC = {
+            id: command.id,
+            type: command.type
+        };
+
+        /**
+         * 上一帧
+         * @type {IArchiveClip["frames"][number]}
+         */
+        const lastFrame = F[F.length - 1];
+
+        /**
+         * 上一帧指令
+         * @type {IArchiveClip["frames"][number]["commands"][number]}
+         */
+        const lastCommand = lastFrame?.commands.filter((c) => {
+            if (c.type === command.type && c.id === command.id) {
+                return true;
+            } else {
+                return false;
+            }
+        })[0];
+
+        // 记录
+        FC.name = (LastFrameData === command.name) ? lastCommand?.name : command.name;
+        
+        FC.data = (LastFrameData === command.data) ? lastCommand?.data : command.data;
+
+        FC.mapId = (LastFrameData === command.mapId) ? lastCommand?.mapId : command.mapId;
+
+        FC.position = (LastFrameData === command.position) ? lastCommand?.position : command.position;
+
+        FC.radius = (LastFrameData === command.radius) ? lastCommand?.radius : command.radius;
+
+        // 获取 Mapper
+        const mapper = objectMapper.get(FC.id);
+        if (mapper) {
+            mapper.type = FC.type ?? mapper.type;
+            mapper.name = FC.name ?? mapper.name;
+        } else {
+            objectMapper.set(FC.id, {
+                type: FC.type,
+                name: FC.name
+            });
+        }
+
+        FCS.push(FC);
+    });
+
+    F.push({
+        duration: frame.duration,
+        process: frame.process,
+        commands: FCS
+    });
+});
+
+console.log("剪辑记录还原成功...\r\n");
+console.log("剪辑共 " + F.length + " 帧, 对象 " + objectMapper.size + " 个\r\n");
+if (objectMapper.size) {
+    console.log("剪辑记录中存在以下对象:");
+} else {
+    console.log("剪辑记录中没有任何对象，退出程序...");
+    process.exit();
+}
+let objectMapperForEachIndex = 1;
+objectMapper.forEach((item, key) => {
+    console.log(" \033[44;30m" + (objectMapperForEachIndex ++) + "\033[40;32m " + item.type + " " + item.name + " [" + key + "]\033[0m");
+});
+
+/**
+ * @type {number[]}
+ */
+const pointMapper = [];
+
+/**
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {number}
+ */
+function getPointID(x, y, z) {
+    let search = -1;
+    let pointMapperLength = (pointMapper.length / 3);
+    // for (let i = 0; i < pointMapperLength; i++) {
+    //     if (
+    //         pointMapper[i * 3 + 0] === x &&
+    //         pointMapper[i * 3 + 1] === y &&
+    //         pointMapper[i * 3 + 2] === z
+    //     ) {
+    //         search = i;
+    //     }
+    // }
+    if (search >= 0) {
+        return search;
+    } else {
+        pointMapper.push(x);
+        pointMapper.push(y);
+        pointMapper.push(z);
+        return pointMapperLength + 1;
+    }
+}
+
+let frameId = 0;
+/**
+ * @type {Map<string, {id: number, start: number, last: number, name: string, point: number[]}[]>}
+ */
+const objectLineMapper = new Map();
+/**
+ * @param {string} obj 
+ * @param {number} id 
+ * @param {number} point 
+ */
+function recordPoint(obj, id, point) {
+    let searchObj = objectLineMapper.get(obj);
+    if (searchObj) {
+
+        /**
+         * @type {{id: number, start: number, last: number, point: number[]}}
+         */
+        let search;
+        for (let i = 0; i < searchObj.length; i++) {
+            if (searchObj[i].id === id && searchObj[i].last === (frameId - 1)) {
+                search = searchObj[i];
+            }
+        }
+
+        if (search) {
+            search.point.push(point);
+            search.last = frameId;
+        } else {
+            searchObj.push({
+                id: id,
+                start: frameId,
+                last: frameId,
+                point: [point]
+            });
+        }
+    } else {
+        objectLineMapper.set(obj, [{
+            id: id,
+            start: frameId,
+            last: frameId,
+            point: [point]
+        }]);
+    }
+}
+
+console.log("\r\n正在收集多边形数据...\r\n");
+for (frameId = 0; frameId < F.length; frameId ++) {
+    F[frameId].commands.forEach((command) => {
+
+        if (command.type === "points" && command.mapId && command.data) {
+            command.mapId.forEach((pid, index) => {
+
+                const x = command.data[index * 3 + 0];
+                const y = command.data[index * 3 + 1]
+                const z = command.data[index * 3 + 2]
+
+                if (
+                    x !== undefined &&
+                    y !== undefined &&
+                    z !== undefined
+                ) {
+                    recordPoint(command.id, pid, getPointID(x, y, z));
+                }
+            })
+        }
+    });
+}
+
+let pointCount = (pointMapper.length / 3);
+
+console.log("收集点数据 " + pointCount + "个\r\n");
+console.log("收集样条:");
+let objectLineMapperIndexPrint = 1;
+objectLineMapper.forEach((item, key) => {
+    let iName = objectMapper.get(key).name;
+    console.log(" \033[44;30m" + (objectLineMapperIndexPrint ++) + "\033[40;32m " + item.length + " " + iName + " [" + key + "]\033[0m");
+});
+
+console.log("\r\n正在生成 .obj 文件...\r\n");
+
+let fileStr = ""; let fileStrVec = "";
+
+objectLineMapper.forEach((item, key) => {
+    
+    for (let i = 0; i < item.length; i++) {
+        fileStr += "\r\n";
+        fileStr += ("o " + objectMapper.get(key).name + " " + item[i].id + "\r\n");
+        fileStr += "usemtl default\r\n";
+        fileStr += "l ";
+        fileStr += getPointID(
+            item[i].start / (F.length - 1),
+            item[i].last / (F.length - 1),
+            (item[i].last - item[i].start) / (F.length - 1)
+        ) + " ";
+        fileStr += item[i].point.join(" ");
+        fileStr += "\r\n";
+    }
+
+    fileStr += "\r\n";
+});
+
+pointCount = (pointMapper.length / 3);
+for (let i = 0; i < pointCount; i++) {
+    fileStrVec += ("v " + pointMapper[i * 3 + 0] + " " + pointMapper[i * 3 + 1] + " " + pointMapper[i * 3 + 2] + "\r\n");
+}
+
+const file = "# Create with Living Together (Parse from .ltss file)\r\n\r\n" + fileStrVec + fileStr;
+
+console.log("正在生成保存文件...\r\n");
+FS.writeFileSync(outputFilePath, file);
+console.log("成功\r\n");

package-lock.json

@@ -19,6 +19,7 @@
         "react-dnd": "^16.0.1",
         "react-dnd-html5-backend": "^16.0.1",
         "react-dom": "^17.0.2",
+        "readline-sync": "^1.4.10",
         "uuid": "^8.3.2"
       },
       "devDependencies": {
@@ -6367,6 +6368,14 @@
         "node": ">=8.10.0"
       }
     },
+    "node_modules/readline-sync": {
+      "version": "1.4.10",
+      "resolved": "https://registry.npmmirror.com/readline-sync/-/readline-sync-1.4.10.tgz",
+      "integrity": "sha512-gNva8/6UAe8QYepIQH/jQ2qn91Qj0B9sYjMBBs3QOB8F2CXcKgLxQaJRP76sWVRQt+QU+8fAkCbCvjjMFu7Ycw==",
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
     "node_modules/rechoir": {
       "version": "0.7.1",
       "resolved": "https://registry.npmjs.org/rechoir/-/rechoir-0.7.1.tgz",
@@ -13309,6 +13318,11 @@
         "picomatch": "^2.2.1"
       }
     },
+    "readline-sync": {
+      "version": "1.4.10",
+      "resolved": "https://registry.npmmirror.com/readline-sync/-/readline-sync-1.4.10.tgz",
+      "integrity": "sha512-gNva8/6UAe8QYepIQH/jQ2qn91Qj0B9sYjMBBs3QOB8F2CXcKgLxQaJRP76sWVRQt+QU+8fAkCbCvjjMFu7Ycw=="
+    },
     "rechoir": {
       "version": "0.7.1",
       "resolved": "https://registry.npmjs.org/rechoir/-/rechoir-0.7.1.tgz",

package.json

@@ -79,6 +79,7 @@
     "react-dnd": "^16.0.1",
     "react-dnd-html5-backend": "^16.0.1",
     "react-dom": "^17.0.2",
+    "readline-sync": "^1.4.10",
     "uuid": "^8.3.2"
   }
 }

source/Behavior/Avoidance.ts

@@ -0,0 +1,86 @@
+import { Behavior } from "@Model/Behavior";
+import { Group } from "@Model/Group";
+import { Individual } from "@Model/Individual";
+import { Model } from "@Model/Model";
+
+type IAvoidanceBehaviorParameter = {
+    avoid: "CLG",
+	strength: "number",
+    range: "number"
+}
+
+type IAvoidanceBehaviorEvent = {}
+
+class Avoidance extends Behavior<IAvoidanceBehaviorParameter, IAvoidanceBehaviorEvent> {
+
+    public override behaviorId: string = "Avoidance";
+
+    public override behaviorName: string = "$Title";
+
+    public override iconName: string = "FastMode";
+
+    public override describe: string = "$Intro";
+
+    public override category: string = "$Interactive";
+
+    public override parameterOption = {
+        avoid: { name: "$Avoid", type: "CLG" },
+        strength: { type: "number", name: "$Strength", defaultValue: 1, numberMin: 0, numberStep: .1 },
+        range: { type: "number", name: "$Range", defaultValue: 4, numberMin: 0, numberStep: .1 }
+    };
+
+    public effect = (individual: Individual, group: Group, model: Model, t: number): void => {
+        
+        let currentDistant: number = Infinity;
+        let avoidTarget = undefined as Individual | undefined;
+
+        for (let i = 0; i < this.parameter.avoid.objects.length; i++) {
+            const targetGroup = this.parameter.avoid.objects[i];
+
+            targetGroup.individuals.forEach((targetIndividual) => {
+
+				// 排除自己
+				if (targetIndividual === individual) return;
+				let dis = targetIndividual.distanceTo(individual);
+
+				if (dis < currentDistant && dis <= this.parameter.range) {
+					avoidTarget = targetIndividual;
+					currentDistant = dis;
+				}
+			});
+        }
+
+        if (avoidTarget && currentDistant !== Infinity) {
+            individual.applyForce(
+				(individual.position[0] - avoidTarget.position[0]) * this.parameter.strength / currentDistant,
+				(individual.position[1] - avoidTarget.position[1]) * this.parameter.strength / currentDistant,
+				(individual.position[2] - avoidTarget.position[2]) * this.parameter.strength / currentDistant
+			);
+        }
+    }
+
+    public override terms: Record<string, Record<string, string>> = {
+        "$Title": {
+            "ZH_CN": "躲避",
+            "EN_US": "Avoidance"
+        },
+        "$Intro": {
+            "ZH_CN": "远离视野范围内最近的躲避目标",
+            "EN_US": "Stay away from the nearest evasive target in the field of vision"
+        },
+        "$Avoid": {
+            "ZH_CN": "躲避对象",
+            "EN_US": "Avoid object"
+        },
+        "$Strength": {
+            "ZH_CN": "躲避强度",
+            "EN_US": "Avoidance intensity"
+        },
+        "$Range": {
+            "ZH_CN": "视野范围",
+            "EN_US": "Field of vision"
+        }
+    };
+}
+
+export { Avoidance };

source/Behavior/Behavior.ts

@@ -7,6 +7,12 @@ import { Tracking } from "@Behavior/Tracking";
 import { ContactAttacking } from "@Behavior/ContactAttacking";
 import { ContactAssimilate } from "@Behavior/ContactAssimilate";
 import { DelayAssimilate } from "@Behavior/DelayAssimilate";
+import { Avoidance } from "@Behavior/Avoidance";
+import { DirectionCluster } from "@Behavior/DirectionCluster";
+import { CentralCluster } from "@Behavior/CentralCluster";
+import { Manufacture } from "@Behavior/Manufacture";
+import { Wastage } from "@Behavior/Wastage";
+import { SampleTracking } from "@Behavior/SampleTracking";
 
 const AllBehaviors: IAnyBehaviorRecorder[] = [
     new BehaviorRecorder(Template),
@@ -17,6 +23,12 @@ const AllBehaviors: IAnyBehaviorRecorder[] = [
     new BehaviorRecorder(ContactAttacking),
     new BehaviorRecorder(ContactAssimilate),
     new BehaviorRecorder(DelayAssimilate),
+    new BehaviorRecorder(Avoidance),
+    new BehaviorRecorder(DirectionCluster),
+    new BehaviorRecorder(CentralCluster),
+    new BehaviorRecorder(Manufacture),
+    new BehaviorRecorder(Wastage),
+    new BehaviorRecorder(SampleTracking),
 ]
 
 /**

source/Behavior/BoundaryConstraint.ts

@@ -48,11 +48,17 @@ class BoundaryConstraint extends Behavior<IBoundaryConstraintBehaviorParameter,
 
 			if (ox || oy || oz) {
 
-				let currentFLen = individual.vectorLength(rx, ry, rz);
+				const backFocus: number[] = [0, 0, 0];
+
+				if (ox) backFocus[0] = rx - rx * rangeList[i].radius[0] / Math.abs(rx);
+				if (oy) backFocus[1] = ry - ry * rangeList[i].radius[1] / Math.abs(ry);
+				if (oz) backFocus[2] = rz - rz * rangeList[i].radius[2] / Math.abs(rz);
+
+				let currentFLen = individual.vectorLength(backFocus);
 				if (currentFLen < fLen) {
-					fx = rx;
-					fy = ry;
-					fz = rz;
+					fx = backFocus[0];
+					fy = backFocus[1];
+					fz = backFocus[2];
 					fLen = currentFLen;
 				}
 

source/Behavior/Brownian.ts

@@ -7,7 +7,9 @@ type IBrownianBehaviorParameter = {
     maxFrequency: "number",
 	minFrequency: "number",
 	maxStrength: "number",
-	minStrength: "number"
+	minStrength: "number",
+	dirLimit: "boolean",
+	angle: "number"
 }
 
 type IBrownianBehaviorEvent = {}
@@ -28,9 +30,88 @@ class Brownian extends Behavior<IBrownianBehaviorParameter, IBrownianBehaviorEve
 		maxFrequency: { type: "number", name: "$Max.Frequency", defaultValue: 5, numberStep: .1, numberMin: 0 },
 		minFrequency: { type: "number", name: "$Min.Frequency", defaultValue: 0, numberStep: .1, numberMin: 0 },
 		maxStrength: { type: "number", name: "$Max.Strength", defaultValue: 10, numberStep: .01, numberMin: 0 },
-		minStrength: { type: "number", name: "$Min.Strength", defaultValue: 0, numberStep: .01, numberMin: 0 }
+		minStrength: { type: "number", name: "$Min.Strength", defaultValue: 0, numberStep: .01, numberMin: 0 },
+		dirLimit: { type: "boolean", name: "$Direction.Limit", defaultValue: false },
+		angle: {
+			type: "number", name: "$Angle", defaultValue: 180, numberStep: 5,
+			numberMin: 0, numberMax: 360, condition: { key: "dirLimit", value: true }
+		}
 	};
 
+	private randomFocus360(): number[] {
+		let randomVec = [
+			Math.random() * 2 - 1,
+			Math.random() * 2 - 1,
+			Math.random() * 2 - 1
+		];
+
+		let randomVecLen = (randomVec[0] ** 2 + randomVec[1] ** 2 + randomVec[2] ** 2) ** 0.5;
+		return [randomVec[0] / randomVecLen, randomVec[1] / randomVecLen, randomVec[2] / randomVecLen];
+	}
+
+	private rotateWithVec(vec: number[], r: number[], ang: number) {
+
+		const cos = Math.cos(ang); const sin = Math.sin(ang);
+		const a1 = r[0] ?? 0; const a2 = r[1] ?? 0; const a3 = r[2] ?? 0; 
+
+		return [
+			(cos + (1 - cos) * a1 * a1) * (vec[0] ?? 0) +
+			((1 - cos) * a1 * a2 - sin * a3) * (vec[1] ?? 0) +
+			((1 - cos) * a1 * a3 + sin * a2) * (vec[2] ?? 0),
+
+			((1 - cos) * a1 * a2 + sin * a3) * (vec[0] ?? 0) +
+			(cos + (1 - cos) * a2 * a2) * (vec[1] ?? 0) +
+			((1 - cos) * a2 * a3 - sin * a1) * (vec[2] ?? 0),
+
+			((1 - cos) * a1 * a3 - sin * a2) * (vec[0] ?? 0) +
+			((1 - cos) * a2 * a3 + sin * a1) * (vec[1] ?? 0) +
+			(cos + (1 - cos) * a3 * a3) * (vec[2] ?? 0)
+		]
+	}
+	private angle2Vector(v1: number[], v2: number[]): number {
+		return Math.acos(
+			(v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2]) /
+			(
+				(v1[0] ** 2 + v1[1] ** 2 + v1[2] ** 2) ** 0.5 *
+				(v2[0] ** 2 + v2[1] ** 2 + v2[2] ** 2) ** 0.5
+			)
+		) * 180 / Math.PI;
+	}
+
+	private randomFocusRange(dir: number[], angle: number): number[] {
+
+		// 计算 X-Z 投影
+		let pxz = [dir[0] ?? 0, 0, dir[2] ?? 0];
+
+		// 通过叉乘计算垂直向量
+		let dxz: number[];
+
+		// 如果投影向量没有长度，使用单位向量
+		if (pxz[0] ** 2 + pxz[2] ** 2 === 0) {
+			dxz = [0, 0, 1];
+		}
+
+		// 通过叉乘计算垂直轴线
+		else {
+			dxz = [
+				dir[1] * pxz[2] - pxz[1] * dir[2],
+				dir[2] * pxz[0] - pxz[2] * dir[0],
+				dir[0] * pxz[1] - pxz[0] * dir[1]
+			];
+
+			let lenDxz = (dxz[0] ** 2 + dxz[1] ** 2 + dxz[2] ** 2) ** 0.5;
+			dxz = [dxz[0] / lenDxz, dxz[1] / lenDxz, dxz[2] / lenDxz];
+		}
+
+		// 航偏角 360 随机旋转
+		let randomH = this.rotateWithVec(dxz, dir, Math.random() * Math.PI * 2);
+
+		// 俯仰角 180 * R 随机旋转
+		let randomP = this.rotateWithVec(dir, randomH, (Math.random() - 0.5) * 2 * angle * Math.PI / 180);
+		
+		return randomP;
+	}
+
 	public effect = (individual: Individual, group: Group, model: Model, t: number): void => {
 
 		const {maxFrequency, minFrequency, maxStrength, minStrength} = this.parameter;
@@ -41,11 +122,49 @@ class Brownian extends Behavior<IBrownianBehaviorParameter, IBrownianBehaviorEve
 		
 		currentTime += t;
 		if (currentTime > nextTime) {
-			individual.applyForce(
-				minStrength + (Math.random() * 2 - 1) * (maxStrength - minStrength),
-				minStrength + (Math.random() * 2 - 1) * (maxStrength - minStrength),
-				minStrength + (Math.random() * 2 - 1) * (maxStrength - minStrength)
+
+			let randomDir: number[];
+
+			// 开启角度限制
+			if (this.parameter.dirLimit) {
+
+				// 计算当前速度大小
+				const vLen = individual.vectorLength(individual.velocity);
+
+				// 随机旋转算法
+				if (vLen > 0) {
+					randomDir = this.randomFocusRange(
+						[
+							individual.velocity[0] / vLen,
+							individual.velocity[1] / vLen,
+							individual.velocity[2] / vLen
+						],
+						this.parameter.angle / 2
 					);
+
+					if (isNaN(randomDir[0]) || isNaN(randomDir[1]) || isNaN(randomDir[2])) {
+						randomDir = this.randomFocus360()
+					}
+				}
+
+				else {
+					randomDir = this.randomFocus360()
+				}
+			}
+			
+			// 随机生成算法
+			else {
+				randomDir = this.randomFocus360()
+			}
+
+			const randomLength = minStrength + Math.random() * (maxStrength - minStrength);
+
+			individual.applyForce(
+				randomDir[0] * randomLength,
+				randomDir[1] * randomLength,
+				randomDir[2] * randomLength
+			);
+
 			nextTime = minFrequency +  Math.random() * (maxFrequency - minFrequency);
 			currentTime = 0;
 		}
@@ -78,6 +197,14 @@ class Brownian extends Behavior<IBrownianBehaviorParameter, IBrownianBehaviorEve
 		"$Min.Strength": {
             "ZH_CN": "最小强度",
             "EN_US": "Minimum strength"
+        },
+		"$Direction.Limit": {
+			"ZH_CN": "开启角度限制",
+            "EN_US": "Enable limit angle"
+		},
+		"$Angle": {
+			"ZH_CN": "限制立体角 (deg)",
+            "EN_US": "Restricted solid angle (deg)"
 		}
     };
 }

source/Behavior/CentralCluster.ts

@@ -0,0 +1,96 @@
+import { Behavior } from "@Model/Behavior";
+import { Group } from "@Model/Group";
+import { Individual } from "@Model/Individual";
+import { Model } from "@Model/Model";
+
+type ICentralClusterBehaviorParameter = {
+    cluster: "CLG",
+	strength: "number",
+    range: "number"
+}
+
+type ICentralClusterBehaviorEvent = {}
+
+class CentralCluster extends Behavior<ICentralClusterBehaviorParameter, ICentralClusterBehaviorEvent> {
+
+    public override behaviorId: string = "CentralCluster";
+
+    public override behaviorName: string = "$Title";
+
+    public override iconName: string = "ZoomToFit";
+
+    public override describe: string = "$Intro";
+
+    public override category: string = "$Interactive";
+
+    public override parameterOption = {
+        cluster: { name: "$Cluster", type: "CLG" },
+        strength: { type: "number", name: "$Strength", defaultValue: 1, numberMin: 0, numberStep: .1 },
+        range: { type: "number", name: "$Range", defaultValue: 4, numberMin: 0, numberStep: .1 }
+    };
+
+    public effect = (individual: Individual, group: Group, model: Model, t: number): void => {
+        
+        let findCount = 0;
+        let centerPos: number[] = [0, 0, 0];
+
+        for (let i = 0; i < this.parameter.cluster.objects.length; i++) {
+            const targetGroup = this.parameter.cluster.objects[i];
+
+            targetGroup.individuals.forEach((targetIndividual) => {
+
+				// 排除自己
+				if (targetIndividual === individual) return;
+				let dis = targetIndividual.distanceTo(individual);
+
+				if (dis <= this.parameter.range) {
+                    centerPos[0] += targetIndividual.position[0];
+                    centerPos[1] += targetIndividual.position[1];
+                    centerPos[2] += targetIndividual.position[2];
+					findCount ++;
+				}
+			});
+        }
+
+        if (findCount > 0) {
+
+            let dirX = centerPos[0] / findCount - individual.position[0];
+            let dirY = centerPos[1] / findCount - individual.position[1];
+            let dirZ = centerPos[2] / findCount - individual.position[2];
+            let length = individual.vectorLength(dirX, dirY, dirZ);
+
+            if (length > 0) {
+                individual.applyForce(
+                    dirX * this.parameter.strength / length,
+                    dirY * this.parameter.strength / length,
+                    dirZ * this.parameter.strength / length
+                );
+            }
+        }
+    }
+
+    public override terms: Record<string, Record<string, string>> = {
+        "$Title": {
+            "ZH_CN": "中心结群",
+            "EN_US": "Central cluster"
+        },
+        "$Intro": {
+            "ZH_CN": "个体将按照视野范围内目标方向结群对象个体的几何中心移动",
+            "EN_US": "The individual will move according to the geometric center of the grouped object individual in the target direction within the field of view"
+        },
+        "$Cluster": {
+            "ZH_CN": "中心结群对象",
+            "EN_US": "Central clustering object"
+        },
+        "$Strength": {
+            "ZH_CN": "结群强度",
+            "EN_US": "Clustering strength"
+        },
+        "$Range": {
+            "ZH_CN": "视野范围",
+            "EN_US": "Field of vision"
+        }
+    };
+}
+
+export { CentralCluster };

source/Behavior/ContactAssimilate.ts

@@ -6,6 +6,7 @@ import { Model } from "@Model/Model";
 type IContactAssimilateBehaviorParameter = {
     target: "CLG",
     assimilate: "CG",
+    self: "CG",
 	success: "number",
     range: "number"
 }
@@ -27,15 +28,13 @@ class ContactAssimilate extends Behavior<IContactAssimilateBehaviorParameter, IC
 	public override parameterOption = {
 		target: { type: "CLG", name: "$Target" },
         assimilate: { type: "CG", name: "$Assimilate" },
+        self: { type: "CG", name: "$Self" },
         range: { type: "number", name: "$Range", defaultValue: .05, numberMin: 0, numberStep: .01 },
         success: { type: "number", name: "$Success", defaultValue: 90, numberMin: 0, numberMax: 100, numberStep: 5 }
 	};
 
     public effect = (individual: Individual, group: Group, model: Model, t: number): void => {
 
-        let assimilateGroup = this.parameter.assimilate.objects;
-        if (!assimilateGroup) return;
-
         for (let i = 0; i < this.parameter.target.objects.length; i++) {
 			const targetGroup = this.parameter.target.objects[i];
 
@@ -50,7 +49,18 @@ class ContactAssimilate extends Behavior<IContactAssimilateBehaviorParameter, IC
 					
                     // 成功判定
                     if (Math.random() * 100 < this.parameter.success) {
-                        targetIndividual.transfer(assimilateGroup!);
+
+                        // 同化目标
+                        let assimilateGroup = this.parameter.assimilate.objects;
+                        if (assimilateGroup) {
+                            targetIndividual.transfer(assimilateGroup);
+                        }
+
+                        // 同化目标
+                        let selfGroup = this.parameter.self.objects;
+                        if (selfGroup) {
+                            individual.transfer(selfGroup);
+                        }
                     }
 				}
 			});
@@ -70,6 +80,10 @@ class ContactAssimilate extends Behavior<IContactAssimilateBehaviorParameter, IC
             "ZH_CN": "到哪个群...",
 			"EN_US": "To group..."
         },
+        "$Self": {
+            "ZH_CN": "自身同化到...",
+			"EN_US": "Self assimilate to..."
+        },
         "$Range": {
             "ZH_CN": "同化范围 (m)",
 			"EN_US": "Assimilate range (m)"

source/Behavior/ContactAttacking.ts

@@ -6,7 +6,8 @@ import { Model } from "@Model/Model";
 type IContactAttackingBehaviorParameter = {
     target: "CLG",
 	success: "number",
-    range: "number"
+    range: "number",
+    assimilate: "CG",
 }
 
 type IContactAttackingBehaviorEvent = {}
@@ -26,7 +27,8 @@ class ContactAttacking extends Behavior<IContactAttackingBehaviorParameter, ICon
 	public override parameterOption = {
 		target: { type: "CLG", name: "$Target" },
         range: { type: "number", name: "$Range", defaultValue: .05, numberMin: 0, numberStep: .01 },
-        success: { type: "number", name: "$Success", defaultValue: 90, numberMin: 0, numberMax: 100, numberStep: 5 }
+        success: { type: "number", name: "$Success", defaultValue: 90, numberMin: 0, numberMax: 100, numberStep: 5 },
+        assimilate: { type: "CG", name: "$Assimilate"}
 	};
 
     public effect = (individual: Individual, group: Group, model: Model, t: number): void => {
@@ -46,6 +48,10 @@ class ContactAttacking extends Behavior<IContactAttackingBehaviorParameter, ICon
                     // 成功判定
                     if (Math.random() * 100 < this.parameter.success) {
                         targetIndividual.die();
+
+                        if (this.parameter.assimilate?.objects) {
+                            individual.transfer(this.parameter.assimilate.objects);
+                        }
                     }
 				}
 			});
@@ -72,6 +78,10 @@ class ContactAttacking extends Behavior<IContactAttackingBehaviorParameter, ICon
         "$Intro": {
             "ZH_CN": "攻击进入共进范围的目标群个体",
             "EN_US": "Attack the target group and individual entering the range"
+        },
+        "$Assimilate": {
+            "ZH_CN": "同化",
+            "EN_US": "Assimilate"
         }
     };
 }

source/Behavior/DirectionCluster.ts

@@ -0,0 +1,93 @@
+import { Behavior } from "@Model/Behavior";
+import { Group } from "@Model/Group";
+import { Individual } from "@Model/Individual";
+import { Model } from "@Model/Model";
+
+type IDirectionClusterBehaviorParameter = {
+    cluster: "CLG",
+	strength: "number",
+    range: "number"
+}
+
+type IDirectionClusterBehaviorEvent = {}
+
+class DirectionCluster extends Behavior<IDirectionClusterBehaviorParameter, IDirectionClusterBehaviorEvent> {
+
+    public override behaviorId: string = "DirectionCluster";
+
+    public override behaviorName: string = "$Title";
+
+    public override iconName: string = "RawSource";
+
+    public override describe: string = "$Intro";
+
+    public override category: string = "$Interactive";
+
+    public override parameterOption = {
+        cluster: { name: "$Cluster", type: "CLG" },
+        strength: { type: "number", name: "$Strength", defaultValue: 1, numberMin: 0, numberStep: .1 },
+        range: { type: "number", name: "$Range", defaultValue: 4, numberMin: 0, numberStep: .1 }
+    };
+
+    public effect = (individual: Individual, group: Group, model: Model, t: number): void => {
+        
+        let findCount = 0;
+        let centerDir: number[] = [0, 0, 0];
+
+        for (let i = 0; i < this.parameter.cluster.objects.length; i++) {
+            const targetGroup = this.parameter.cluster.objects[i];
+
+            targetGroup.individuals.forEach((targetIndividual) => {
+
+				// 排除自己
+				if (targetIndividual === individual) return;
+				let dis = targetIndividual.distanceTo(individual);
+
+				if (dis <= this.parameter.range) {
+                    centerDir[0] += targetIndividual.velocity[0];
+                    centerDir[1] += targetIndividual.velocity[1];
+                    centerDir[2] += targetIndividual.velocity[2];
+					findCount ++;
+				}
+			});
+        }
+
+        if (findCount > 0) {
+
+            let length = individual.vectorLength(centerDir);
+
+            if (length) {
+                individual.applyForce(
+                    centerDir[0] * this.parameter.strength / length,
+                    centerDir[1] * this.parameter.strength / length,
+                    centerDir[2] * this.parameter.strength / length
+                );
+            }
+        }
+    }
+
+    public override terms: Record<string, Record<string, string>> = {
+        "$Title": {
+            "ZH_CN": "方向结群",
+            "EN_US": "Directional clustering"
+        },
+        "$Intro": {
+            "ZH_CN": "个体将按照视野范围内目标方向结群对象个体的平均移动方向移动",
+            "EN_US": "Individuals will move according to the average moving direction of the grouped object individuals in the target direction within the field of vision"
+        },
+        "$Cluster": {
+            "ZH_CN": "方向结群对象",
+            "EN_US": "Directional clustering object"
+        },
+        "$Strength": {
+            "ZH_CN": "结群强度",
+            "EN_US": "Clustering strength"
+        },
+        "$Range": {
+            "ZH_CN": "视野范围",
+            "EN_US": "Field of vision"
+        }
+    };
+}
+
+export { DirectionCluster };

source/Behavior/Manufacture.ts

@@ -0,0 +1,83 @@
+import { Behavior } from "@Model/Behavior";
+import { Group } from "@Model/Group";
+import { Individual } from "@Model/Individual";
+import { Model } from "@Model/Model";
+
+type IManufactureBehaviorParameter = {
+    maxFrequency: "number",
+	minFrequency: "number",
+	genTarget: "CG",
+}
+
+type IManufactureBehaviorEvent = {}
+
+class Manufacture extends Behavior<IManufactureBehaviorParameter, IManufactureBehaviorEvent> {
+
+    public override behaviorId: string = "Manufacture";
+
+    public override behaviorName: string = "$Title";
+
+    public override iconName: string = "ProductionFloorManagement";
+
+    public override describe: string = "$Intro";
+
+	public override category: string = "$Initiative";
+
+	public override parameterOption = {
+        genTarget: { type: "CG", name: "$Gen.Target" },
+		maxFrequency: { type: "number", name: "$Max.Frequency", defaultValue: 5, numberStep: .1, numberMin: 0 },
+		minFrequency: { type: "number", name: "$Min.Frequency", defaultValue: 0, numberStep: .1, numberMin: 0 }
+	};
+
+	public effect = (individual: Individual, group: Group, model: Model, t: number): void => {
+
+		const {genTarget, maxFrequency, minFrequency} = this.parameter;
+
+        if (genTarget.objects) {
+            
+            let nextTime = individual.getData("Manufacture.nextTime") ?? 
+            minFrequency + Math.random() * (maxFrequency - minFrequency);
+            let currentTime = individual.getData("Manufacture.currentTime") ?? 0;
+
+            if (currentTime > nextTime) {
+
+                // 生成个体
+                let newIndividual = genTarget.objects.new(1);
+                newIndividual.position = individual.position.concat([]);
+                
+                nextTime = minFrequency +  Math.random() * (maxFrequency - minFrequency);
+                currentTime = 0;
+            }
+            
+            currentTime += t;
+
+            individual.setData("Manufacture.nextTime", nextTime);
+		    individual.setData("Manufacture.currentTime", currentTime);
+        }
+	}
+
+	public override terms: Record<string, Record<string, string>> = {
+        "$Title": {
+            "ZH_CN": "生产",
+            "EN_US": "Manufacture"
+        },
+        "$Intro": {
+            "ZH_CN": "在指定的群创造新的个体",
+            "EN_US": "Create new individuals in a given group"
+        },
+        "$Gen.Target": {
+            "ZH_CN": "目标群",
+            "EN_US": "Target group"
+        },
+		"$Max.Frequency": {
+            "ZH_CN": "最大频率",
+            "EN_US": "Maximum frequency"
+        },
+		"$Min.Frequency": {
+            "ZH_CN": "最小频率",
+            "EN_US": "Minimum frequency"
+        }
+    };
+}
+
+export { Manufacture };

source/Behavior/PhysicsDynamics.ts

@@ -31,11 +31,11 @@ class PhysicsDynamics extends Behavior<IPhysicsDynamicsBehaviorParameter, IPhysi
 		limit: { name: "$Limit", type: "boolean", defaultValue: true },
 		maxAcceleration: {
 			name: "$Max.Acceleration", type: "number", defaultValue: 6.25, 
-			numberStep: .1, numberMin: 0, condition: { key: "limit", value: true }
+			numberStep: .1, numberMin: 0.0001, condition: { key: "limit", value: true }
 		},
 		maxVelocity: {
 			name: "$Max.Velocity", type: "number", defaultValue: 12.5,
-			numberStep: .1, numberMin: 0, condition: { key: "limit", value: true }
+			numberStep: .1, numberMin: 0.0001, condition: { key: "limit", value: true }
 		},
 	};
 
@@ -64,7 +64,7 @@ class PhysicsDynamics extends Behavior<IPhysicsDynamicsBehaviorParameter, IPhysi
 		// 加速度约束
 		if (this.parameter.limit) {
 			const lengthA = individual.vectorLength(individual.acceleration);
-			if (lengthA > this.parameter.maxAcceleration) {
+			if (lengthA > this.parameter.maxAcceleration && lengthA) {
 				individual.acceleration[0] = individual.acceleration[0] * this.parameter.maxAcceleration / lengthA;
 				individual.acceleration[1] = individual.acceleration[1] * this.parameter.maxAcceleration / lengthA;
 				individual.acceleration[2] = individual.acceleration[2] * this.parameter.maxAcceleration / lengthA;
@@ -79,7 +79,7 @@ class PhysicsDynamics extends Behavior<IPhysicsDynamicsBehaviorParameter, IPhysi
 		// 速度约束
 		if (this.parameter.limit) {
 			const lengthV = individual.vectorLength(individual.velocity);
-			if (lengthV > this.parameter.maxVelocity) {
+			if (lengthV > this.parameter.maxVelocity && lengthV) {
 				individual.velocity[0] = individual.velocity[0] * this.parameter.maxVelocity / lengthV;
 				individual.velocity[1] = individual.velocity[1] * this.parameter.maxVelocity / lengthV;
 				individual.velocity[2] = individual.velocity[2] * this.parameter.maxVelocity / lengthV;

source/Behavior/SampleTracking.ts

@@ -0,0 +1,160 @@
+import { Behavior } from "@Model/Behavior";
+import { Group } from "@Model/Group";
+import { Individual } from "@Model/Individual";
+import { Model } from "@Model/Model";
+
+type ISampleTrackingBehaviorParameter = {
+    target: "CLG",
+    key: "string",
+	strength: "number",
+    range: "number",
+    angle: "number",
+    accuracy: "number"
+}
+
+type ISampleTrackingBehaviorEvent = {}
+
+class SampleTracking extends Behavior<ISampleTrackingBehaviorParameter, ISampleTrackingBehaviorEvent> {
+
+    public override behaviorId: string = "SampleTracking";
+
+    public override behaviorName: string = "$Title";
+
+    public override iconName: string = "Video360Generic";
+
+    public override describe: string = "$Intro";
+
+    public override category: string = "$Initiative";
+
+	public override parameterOption = {
+		target: { type: "CLG", name: "$Target" },
+        key: { type: "string", name: "$Key"},
+        range: { type: "number", name: "$Range", defaultValue: 4, numberMin: 0, numberStep: .1 },
+        angle: { type: "number", name: "$Angle", defaultValue: 180, numberMin: 0, numberMax: 360, numberStep: 5 },
+		strength: { type: "number", name: "$Strength", defaultValue: 1, numberMin: 0, numberStep: .1 },
+        accuracy: { type: "number", name: "$Accuracy", defaultValue: 5, numberMin: 0, numberMax: 180, numberStep: 1 }
+	};
+
+    private angle2Vector(v1: number[], v2: number[]): number {
+		return Math.acos(
+			(v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2]) /
+			(
+				(v1[0] ** 2 + v1[1] ** 2 + v1[2] ** 2) ** 0.5 *
+				(v2[0] ** 2 + v2[1] ** 2 + v2[2] ** 2) ** 0.5
+			)
+		) * 180 / Math.PI;
+	}
+
+    public effect = (individual: Individual, group: Group, model: Model, t: number): void => {
+
+        const dirArr: number[][] = []; const valArr: number[] = [];
+
+        for (let i = 0; i < this.parameter.target.objects.length; i++) {
+            const targetGroup = this.parameter.target.objects[i];
+
+			targetGroup.individuals.forEach((targetIndividual) => {
+
+                // 计算距离
+                let dis = targetIndividual.distanceTo(individual);
+                if (dis > this.parameter.range) return;
+
+                // 计算方向
+                let targetDir = [
+                    targetIndividual.position[0] - individual.position[0],
+                    targetIndividual.position[1] - individual.position[1],
+                    targetIndividual.position[2] - individual.position[2]
+                ];
+
+                // 计算视线角度
+                let angle = this.angle2Vector(individual.velocity, targetDir);
+
+                // 在可视角度内
+                if (angle < (this.parameter.angle ?? 360) / 2) {
+
+                    // 采样
+                    let isFindNest = false;
+                    for (let i = 0; i < valArr.length; i++) {
+
+                        // 计算采样角度
+                        let sampleAngle = this.angle2Vector(dirArr[i], targetDir);
+
+                        // 小于采样精度，合并
+                        if (sampleAngle < this.parameter.accuracy ?? 5) {
+                            dirArr[i][0] += targetDir[0];
+                            dirArr[i][1] += targetDir[1];
+                            dirArr[i][2] += targetDir[2];
+                            valArr[i] += targetIndividual.getData(this.parameter.key) ?? 0;
+                            isFindNest = true;
+                        }
+                    }
+
+                    if (!isFindNest) {
+
+                        // 保存
+                        dirArr.push(targetDir);
+                        valArr.push(targetIndividual.getData(this.parameter.key) ?? 0);
+                    }
+                }
+            });
+        }
+
+        // 计算最大方向
+        let maxVal = -1; let maxDir: number[] | undefined;
+        for (let i = 0; i < valArr.length; i++) {
+            if (valArr[i] > maxVal) {
+                maxVal = valArr[i];
+                maxDir = dirArr[i];
+            }
+        }
+
+        if (maxDir) {
+            const dir = individual.vectorNormalize(maxDir);
+            individual.applyForce(
+                dir[0] * this.parameter.strength,
+                dir[1] * this.parameter.strength,
+                dir[2] * this.parameter.strength
+            );
+        }
+    }
+
+	public override terms: Record<string, Record<string, string>> = {
+        "$Title": {
+            "ZH_CN": "采样追踪",
+            "EN_US": "Sample tracking"
+        },
+		"$Target": {
+			"ZH_CN": "追踪目标",
+			"EN_US": "Tracking target"
+		},
+        "$Key": {
+            "ZH_CN": "计算键值",
+			"EN_US": "Calculate key value"
+        },
+        "$Accuracy": {
+            "ZH_CN": "采样精度",
+			"EN_US": "Sampling accuracy"
+        },
+        "$Range": {
+            "ZH_CN": "追踪范围 (m)",
+			"EN_US": "Tracking range (m)"
+        },
+		"$Strength": {
+			"ZH_CN": "追踪强度系数",
+			"EN_US": "Tracking intensity coefficient"
+		},
+        "$Intro": {
+            "ZH_CN": "个体将主动向目标个体较多的方向发起追踪",
+            "EN_US": "Individuals will actively initiate tracking in the direction of more target individuals"
+        },
+		"$Interactive": {
+			"ZH_CN": "交互",
+            "EN_US": "Interactive"
+		},
+        "$Angle": {
+            "ZH_CN": "可视角度",
+            "EN_US": "Viewing angle"
+        }
+    };
+}
+
+export { SampleTracking };

source/Behavior/Tracking.ts

@@ -7,6 +7,7 @@ type ITrackingBehaviorParameter = {
     target: "CLG",
 	strength: "number",
     range: "number",
+    angle: "number",
     lock: "boolean"
 }
 
@@ -28,12 +29,23 @@ class Tracking extends Behavior<ITrackingBehaviorParameter, ITrackingBehaviorEve
 		target: { type: "CLG", name: "$Target" },
         lock: { type: "boolean", name: "$Lock", defaultValue: false },
         range: { type: "number", name: "$Range", defaultValue: 4, numberMin: 0, numberStep: .1 },
+        angle: { type: "number", name: "$Angle", defaultValue: 180, numberMin: 0, numberMax: 360, numberStep: 5 },
 		strength: { type: "number", name: "$Strength", defaultValue: 1, numberMin: 0, numberStep: .1 }
 	};
 
     private target: Individual | undefined = undefined;
     private currentDistant: number = Infinity;
 
+    private angle2Vector(v1: number[], v2: number[]): number {
+		return Math.acos(
+			(v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2]) /
+			(
+				(v1[0] ** 2 + v1[1] ** 2 + v1[2] ** 2) ** 0.5 *
+				(v2[0] ** 2 + v2[1] ** 2 + v2[2] ** 2) ** 0.5
+			)
+		) * 180 / Math.PI;
+	}
+
     private searchTarget(individual: Individual) {
 
 		for (let i = 0; i < this.parameter.target.objects.length; i++) {
@@ -46,8 +58,21 @@ class Tracking extends Behavior<ITrackingBehaviorParameter, ITrackingBehaviorEve
 				let dis = targetIndividual.distanceTo(individual);
 
 				if (dis < this.currentDistant && dis <= this.parameter.range) {
+
+                    // 计算目标方位
+                    const targetDir = [
+                        targetIndividual.position[0] - individual.position[0],
+                        targetIndividual.position[1] - individual.position[1],
+                        targetIndividual.position[2] - individual.position[2]
+                    ];
+
+                    // 计算角度
+                    const angle = this.angle2Vector(individual.velocity, targetDir);
+
+                    if (angle < (this.parameter.angle ?? 360) / 2) {
                         this.target = targetIndividual;
 					    this.currentDistant = dis;
+                    }
 				}
 
 			});
@@ -150,6 +175,10 @@ class Tracking extends Behavior<ITrackingBehaviorParameter, ITrackingBehaviorEve
 		"$Interactive": {
 			"ZH_CN": "交互",
             "EN_US": "Interactive"
+		},
+        "$Angle": {
+            "ZH_CN": "可视角度",
+            "EN_US": "Viewing angle"
         }
     };
 }

source/Behavior/Wastage.ts

@@ -0,0 +1,100 @@
+import { Behavior } from "@Model/Behavior";
+import { Group } from "@Model/Group";
+import { Individual } from "@Model/Individual";
+import { Model } from "@Model/Model";
+
+type IWastageBehaviorParameter = {
+    key: "string",
+    value: "number",
+    speed: "number",
+    threshold: "number",
+    kill: "boolean",
+    assimilate: "CG"
+}
+
+type IWastageBehaviorEvent = {}
+
+class Wastage extends Behavior<IWastageBehaviorParameter, IWastageBehaviorEvent> {
+
+    public override behaviorId: string = "Wastage";
+
+    public override behaviorName: string = "$Title";
+
+    public override iconName: string = "BackgroundColor";
+
+    public override describe: string = "$Intro";
+
+    public override category: string = "$Initiative";
+
+    public override parameterOption = {
+        key: { type: "string", name: "$Key" },
+        value: { type: "number", name: "$Value", defaultValue: 100, numberStep: 1 },
+        speed: { type: "number", name: "$Speed", defaultValue: 1, numberStep: .1 },
+        threshold: { type: "number", name: "$Threshold", defaultValue: 0, numberStep: 1 },
+        kill: { type: "boolean", name: "$Kill", defaultValue: true },
+        assimilate: { type: "CG", name: "$Assimilate", condition: { key: "kill", value: false } }
+    };
+
+    public effect = (individual: Individual, group: Group, model: Model, t: number): void => {
+        const key = this.parameter.key;
+        if (!key) return;
+        
+        let currentValue = individual.getData(`Wastage.${key}`) ?? this.parameter.value;
+        currentValue -= this.parameter.speed * t;
+
+        // 超过阈值
+        if (currentValue < this.parameter.threshold) {
+
+            currentValue = undefined;
+
+            // 杀死个体
+            if (this.parameter.kill) {
+                individual.die();
+            }
+
+            // 开启同化
+            else if (this.parameter.assimilate.objects) {
+                individual.transfer(this.parameter.assimilate.objects);
+            }
+        }
+
+        individual.setData(`Wastage.${key}`, currentValue);
+    }
+
+    public override terms: Record<string, Record<string, string>> = {
+        "$Title": {
+            "ZH_CN": "流逝",
+            "EN_US": "Wastage"
+        },
+        "$Intro": {
+            "ZH_CN": "随着时间流逝",
+            "EN_US": "As time goes by"
+        },
+        "$Key": {
+            "ZH_CN": "元数据",
+            "EN_US": "Metadata"
+        },
+        "$Value": {
+            "ZH_CN": "默认数值",
+            "EN_US": "Default value"
+        },
+        "$Speed": {
+            "ZH_CN": "流逝速度 (c/s)",
+            "EN_US": "Passing speed (c/s)"
+        },
+        "$Threshold": {
+            "ZH_CN": "阈值",
+            "EN_US": "Threshold"
+        },
+        "$Kill": {
+            "ZH_CN": "死亡",
+            "EN_US": "Death"
+        },
+        "$Assimilate": {
+            "ZH_CN": "同化",
+            "EN_US": "Assimilate"
+        }
+    };
+}
+
+export { Wastage };

source/Component/CommandBar/CommandBar.tsx

@@ -9,6 +9,7 @@ import { SettingPopup } from "@Component/SettingPopup/SettingPopup";
 import { BehaviorPopup } from "@Component/BehaviorPopup/BehaviorPopup";
 import { MouseMod } from "@GLRender/ClassicRenderer";
 import { ArchiveSave } from "@Context/Archive";
+import { ActuatorModel } from "@Model/Actuator";
 import "./CommandBar.scss";
 
 const COMMAND_BAR_WIDTH = 45;
@@ -50,6 +51,62 @@ class CommandBar extends Component<IMixinSettingProps & IMixinStatusProps, IComm
         isSaveRunning: false
     };
 
+    private renderPlayActionButton(): ReactNode {
+
+        let icon: string = "Play";
+        let handel: () => any = () => {};
+
+        // 播放模式
+        if (this.props.status?.focusClip) {
+
+            // 暂停播放
+            if (this.props.status?.actuator.mod === ActuatorModel.Play) {
+                icon = "Pause";
+                handel = () => {
+                    this.props.status?.actuator.pausePlay();
+					console.log("ClipRecorder: Pause play...");
+                };
+            }
+
+            // 开始播放
+            else {
+                icon = "Play";
+                handel = () => {
+                    this.props.status?.actuator.playing();
+					console.log("ClipRecorder: Play start...");
+                };
+            }
+        }
+        
+        // 正在录制中
+        else if (
+            this.props.status?.actuator.mod === ActuatorModel.Record ||
+			this.props.status?.actuator.mod === ActuatorModel.Offline
+        ) {
+
+            // 暂停录制
+            icon = "Stop";
+            handel = () => {
+                this.props.status?.actuator.endRecord();
+                console.log("ClipRecorder: Rec end...");
+            };
+        }
+
+        // 正常控制主时钟
+        else {
+            icon = this.props.status?.actuator.start() ? "Pause" : "Play";
+            handel = () => this.props.status?.actuator.start(
+                !this.props.status?.actuator.start()
+            );
+        }
+
+        return <CommandButton
+            iconName={icon}
+            i18NKey="Command.Bar.Play.Info"
+            click={handel}
+        />;
+    }
+
     public render(): ReactNode {
 
         const mouseMod = this.props.status?.mouseMod ?? MouseMod.Drag;
@@ -84,13 +141,7 @@ class CommandBar extends Component<IMixinSettingProps & IMixinStatusProps, IComm
                     }}
                 />
 
-                <CommandButton
-                    iconName={this.props.status?.actuator.start() ? "Pause" : "Play"}
-                    i18NKey="Command.Bar.Play.Info"
-                    click={() => this.props.status ? this.props.status.actuator.start(
-                        !this.props.status.actuator.start()
-                    ) : undefined}
-                />
+                {this.renderPlayActionButton()}
 
                 <CommandButton
                     iconName="HandsFree"
@@ -137,11 +188,6 @@ class CommandBar extends Component<IMixinSettingProps & IMixinStatusProps, IComm
                         this.props.status ? this.props.status.newLabel() : undefined;
                     }}
                 />
-
-                <CommandButton
-                    iconName="Camera"
-                    i18NKey="Command.Bar.Camera.Info"
-                />
             </div>
             <div>
                 <CommandButton

source/Component/OfflineRender/OfflineRender.scss

@@ -0,0 +1,8 @@
+@import "../Theme/Theme.scss";
+
+div.offline-render-popup {
+	width: 100%;
+	height: 100%;
+	box-sizing: border-box;
+	padding: 10px;
+}

source/Component/OfflineRender/OfflineRender.tsx

@@ -0,0 +1,124 @@
+import { Component, ReactNode } from "react";
+import { Popup } from "@Context/Popups";
+import { useStatusWithEvent, IMixinStatusProps } from "@Context/Status";
+import { Localization } from "@Component/Localization/Localization";
+import { AttrInput } from "@Input/AttrInput/AttrInput";
+import { Message } from "@Input/Message/Message";
+import { ConfirmContent } from "@Component/ConfirmPopup/ConfirmPopup";
+import { ProcessPopup } from "@Component/ProcessPopup/ProcessPopup";
+import { Emitter } from "@Model/Emitter";
+import "./OfflineRender.scss";
+
+interface IOfflineRenderProps {
+	close?: () => any;
+}
+
+interface IOfflineRenderState {
+	time: number;
+	fps: number;
+	name: string;
+}
+
+class OfflineRender extends Popup<IOfflineRenderProps> {
+
+	public minWidth: number = 250;
+	public minHeight: number = 150;
+	public width: number = 400;
+	public height: number = 300;
+
+	public maskForSelf: boolean = true;
+
+	public onRenderHeader(): ReactNode {
+		return <Localization i18nKey="Popup.Offline.Render.Title"/>
+	}
+
+	public render(): ReactNode {
+		return <OfflineRenderComponent {...this.props} close={() => {
+			this.close();
+		}}/>
+	}
+}
+
+@useStatusWithEvent()
+class OfflineRenderComponent extends Component<IOfflineRenderProps & IMixinStatusProps, IOfflineRenderState> {
+
+	public constructor(props: IOfflineRenderProps & IMixinStatusProps) {
+		super(props);
+		this.state = {
+			name: this.props.status?.getNewClipName() ?? "",
+			time: 10,
+			fps: 60
+		}
+	}
+
+	public render(): ReactNode {
+		return <ConfirmContent
+			className="offline-render-popup"
+			actions={[{
+				i18nKey: "Popup.Offline.Render.Input.Start",
+				onClick: () => {
+
+					// 获取新实例
+					let newClip = this.props.status?.newClip();
+
+					if (newClip) {
+						newClip.name = this.state.name;
+						this.props.status?.actuator.offlineRender(newClip, this.state.time, this.state.fps);
+
+						// 开启进度条弹窗
+						this.props.status?.popup.showPopup(ProcessPopup, {});
+					}
+
+					// 关闭这个弹窗
+					this.props.close && this.props.close();
+				}
+			}]}
+		>
+
+			<Message i18nKey="Popup.Offline.Render.Message" isTitle first/>
+
+			<AttrInput
+                id={"Render-Name"}
+				value={this.state.name}
+				keyI18n="Popup.Offline.Render.Input.Name"
+				maxLength={15}
+                valueChange={(val) => {
+                    this.setState({
+						name: val
+					});
+                }}
+            />
+
+			<AttrInput
+				isNumber
+                id={"Render-Time"}
+				value={this.state.time}
+				keyI18n="Popup.Offline.Render.Input.Time"
+				max={3600}
+				min={1}
+                valueChange={(val) => {
+                    this.setState({
+						time: parseFloat(val)
+					});
+                }}
+            />
+
+			<AttrInput
+				isNumber
+                id={"Render-FPS"}
+				max={1000}
+				min={1}
+				value={this.state.fps}
+				keyI18n="Popup.Offline.Render.Input.Fps"
+                valueChange={(val) => {
+                    this.setState({
+						fps: parseFloat(val)
+					});
+                }}
+            />
+
+		</ConfirmContent>
+	}
+}
+
+export { OfflineRender };

source/Component/ProcessPopup/ProcessPopup.scss

@@ -0,0 +1,42 @@
+@import "../Theme/Theme.scss";
+
+div.process-popup {
+	width: 100%;
+	height: 100%;
+	box-sizing: border-box;
+	padding: 10px;
+
+	div.ms-ProgressIndicator {
+		transform: none;
+
+		div.ms-ProgressIndicator-progressTrack {
+			transform: none;
+		}
+	
+		div.ms-ProgressIndicator-progressBar {
+			transform: none;
+		}
+	}
+}
+
+div.confirm-root.dark div.ms-ProgressIndicator {
+
+	div.ms-ProgressIndicator-progressTrack {
+		background-color: $lt-bg-color-lvl3-dark;
+	}
+
+	div.ms-ProgressIndicator-progressBar {
+		background-color: $lt-font-color-normal-dark;
+	}
+}
+
+div.confirm-root.light div.ms-ProgressIndicator {
+
+	div.ms-ProgressIndicator-progressTrack {
+		background-color: $lt-bg-color-lvl3-light;
+	}
+
+	div.ms-ProgressIndicator-progressBar {
+		background-color: $lt-font-color-normal-light;
+	}
+}

source/Component/ProcessPopup/ProcessPopup.tsx

@@ -0,0 +1,89 @@
+import { Component, ReactNode } from "react";
+import { Popup } from "@Context/Popups";
+import { Localization } from "@Component/Localization/Localization";
+import { ConfirmContent } from "@Component/ConfirmPopup/ConfirmPopup";
+import { useStatusWithEvent, IMixinStatusProps } from "@Context/Status";
+import { ProgressIndicator } from "@fluentui/react";
+import { ActuatorModel } from "@Model/Actuator";
+import "./ProcessPopup.scss";
+
+interface IProcessPopupProps {
+	close?: () => void;
+}
+
+class ProcessPopup extends Popup<IProcessPopupProps> {
+
+	public minWidth: number = 400;
+	public minHeight: number = 150;
+	public width: number = 400;
+	public height: number = 150;
+
+	public maskForSelf: boolean = true;
+
+	public onClose(): void {}
+
+	public onRenderHeader(): ReactNode {
+		return <Localization i18nKey="Popup.Offline.Render.Process.Title"/>
+	}
+
+	public render(): ReactNode {
+		return <ProcessPopupComponent {...this.props} close={() => this.close()}/>
+	}
+}
+
+@useStatusWithEvent("offlineLoop", "actuatorStartChange", "recordLoop")
+class ProcessPopupComponent extends Component<IProcessPopupProps & IMixinStatusProps> {
+
+	public render(): ReactNode {
+
+		let current = this.props.status?.actuator.offlineCurrentFrame ?? 0;
+		let all = this.props.status?.actuator.offlineAllFrame ?? 0;
+
+		const isRendering = this.props.status?.actuator.mod === ActuatorModel.Offline;
+		let i18nKey = "";
+		let color: undefined | "red";
+		let onClick = () => {};
+
+		if (isRendering) {
+			i18nKey = "Popup.Offline.Render.Input.End";
+			color = "red";
+			onClick = () => {
+				this.props.status?.actuator.endOfflineRender();
+				this.forceUpdate();
+			}
+		}
+
+		else {
+			i18nKey = "Popup.Offline.Render.Input.Finished";
+			onClick = () => {
+				this.props.close && this.props.close();
+			}
+		}
+
+		return <ConfirmContent
+			className="process-popup"
+			actions={[{
+				i18nKey: i18nKey,
+				color: color,
+				onClick: onClick
+			}]}
+		>
+
+			<ProgressIndicator
+				percentComplete={current / all}
+				barHeight={3}
+			/>
+
+			<Localization
+				i18nKey="Popup.Offline.Render.Process"
+				options={{
+					current: current.toString(),
+					all: all.toString()
+				}}
+			/>
+
+		</ConfirmContent>
+	}
+}
+
+export { ProcessPopup };

source/Component/Recorder/Recorder.scss

@@ -30,7 +30,7 @@ div.recorder-root {
 		
 		span.ms-Slider-inactive {
 			height: 3px;
-			animation: none;
+			transition: none;
 		}
 	}
 

source/Component/Recorder/Recorder.tsx

@@ -14,6 +14,7 @@ interface IRecorderProps {
 	allTime?: number;
 	currentTime?: number;
 	action?: () => void;
+	valueChange?: (value: number) => any;
 }
 
 class Recorder extends Component<IRecorderProps> {
@@ -85,19 +86,38 @@ class Recorder extends Component<IRecorderProps> {
 				max={this.props.allFrame}
 				className={"recorder-slider" + (isSliderDisable ? " disable" : "")}
 				showValue={false}
+				onChange={(value) => {
+					if (this.props.valueChange && !isSliderDisable) {
+						this.props.valueChange(value);
+					}
+				}}
 			/>
 			<div className="recorder-content">
 				<div className="time-view">
 					{this.getRecordInfo()}
 				</div>
 				<div className="ctrl-button">
-					<div className={"ctrl-action" + (isJumpDisable ? " disable" : "")}>
+					<div
+						className={"ctrl-action" + (isJumpDisable ? " disable" : "")}
+						onClick={() => {
+							if (this.props.valueChange && !isJumpDisable && this.props.currentFrame !== undefined) {
+								this.props.valueChange(this.props.currentFrame - 1);
+							}
+						}}
+					>
 						<Icon iconName="Back"/>
 					</div>
 					<div className="ctrl-action ctrl-action-main" onClick={this.props.action}>
 						<Icon iconName={this.getActionIcon()}/>
 					</div>
-					<div className={"ctrl-action" + (isJumpDisable ? " disable" : "")}>
+					<div
+						className={"ctrl-action" + (isJumpDisable ? " disable" : "")}
+						onClick={() => {
+							if (this.props.valueChange && !isJumpDisable && this.props.currentFrame !== undefined) {
+								this.props.valueChange(this.props.currentFrame + 1);
+							}
+						}}
+					>
 						<Icon iconName="Forward"/>
 					</div>
 				</div>

source/Component/SettingPopup/SettingPopup.scss

@@ -3,4 +3,6 @@
 div.setting-popup {
 	width: 100%;
 	height: 100%;
+	box-sizing: border-box;
+	padding: 10px;
 }

source/Component/SettingPopup/SettingPopup.tsx

@@ -2,8 +2,11 @@ import { Component, ReactNode } from "react";
 import { Popup } from "@Context/Popups";
 import { Theme } from "@Component/Theme/Theme";
 import { Localization } from "@Component/Localization/Localization";
+import { useSettingWithEvent, IMixinSettingProps, Themes } from "@Context/Setting";
+import { ComboInput } from "@Input/ComboInput/ComboInput";
 import "./SettingPopup.scss";
 
+
 interface ISettingPopupProps {
 
 }
@@ -24,10 +27,42 @@ class SettingPopup extends Popup<ISettingPopupProps> {
 	}
 }
 
-class SettingPopupComponent extends Component<ISettingPopupProps> {
+@useSettingWithEvent("themes", "language")
+class SettingPopupComponent extends Component<ISettingPopupProps & IMixinSettingProps> {
 
 	public render(): ReactNode {
-		return <Theme className="setting-popup"></Theme>
+		return <Theme className="setting-popup">
+
+			<ComboInput
+				keyI18n="Language"
+				allOption={[
+					{ key: "EN_US", i18n: "EN_US" },
+					{ key: "ZH_CN", i18n: "ZH_CN" }
+				]}
+				value={{
+					key: this.props.setting?.language ?? "EN_US",
+					i18n: this.props.setting?.language ?? "EN_US"
+				}}
+				valueChange={(data) => {
+					this.props.setting?.setProps("language", data.key as any);
+				}}
+			/>
+
+			<ComboInput
+				keyI18n="Themes"
+				allOption={[
+					{ key: Themes.dark as any, i18n: "Themes.Dark" },
+					{ key: Themes.light as any, i18n: "Themes.Light" }
+				]}
+				value={{
+					key: this.props.setting?.themes ?? Themes.dark as any,
+					i18n: this.props.setting?.themes === Themes.dark ? "Themes.Dark" : "Themes.Light"
+				}}
+				valueChange={(data) => {
+					this.props.setting?.setProps("themes", parseInt(data.key));
+				}}
+			/>
+		</Theme>
 	}
 }
 

source/Context/Status.tsx

@@ -37,6 +37,7 @@ interface IStatusEvent {
     renderLoop: number;
     physicsLoop: number;
     recordLoop: number;
+    offlineLoop: number;
     mouseModChange: void;
     focusObjectChange: void;
     focusLabelChange: void;
@@ -52,6 +53,7 @@ interface IStatusEvent {
     labelAttrChange: void;
     groupAttrChange: void;
     behaviorAttrChange: void;
+    clipAttrChange: void;
     individualChange: void;
     behaviorChange: void;
     popupChange: void;
@@ -129,6 +131,7 @@ class Status extends Emitter<IStatusEvent> {
         // 循环事件
         this.actuator.on("loop", (t) => { this.emit("physicsLoop", t) });
         this.actuator.on("record", (t) => { this.emit("recordLoop", t) });
+        this.actuator.on("offline", (t) => { this.emit("offlineLoop", t) });
 
         // 对象变化事件
         this.model.on("objectChange", () => this.emit("objectChange"));
@@ -171,11 +174,13 @@ class Status extends Emitter<IStatusEvent> {
             this.emit("objectChange");
             this.emit("labelChange");
             this.emit("behaviorChange");
+            this.emit("clipChange");
 
             // 清除焦点对象
             this.setBehaviorObject();
             this.setFocusObject(new Set());
             this.setLabelObject();
+            this.setClipObject();
 
             // 映射
             this.emit("fileLoad");
@@ -193,11 +198,13 @@ class Status extends Emitter<IStatusEvent> {
         this.on("objectChange", handelFileChange);
         this.on("behaviorChange", handelFileChange);
         this.on("labelChange", handelFileChange);
+        this.on("clipChange", handelFileChange);
         this.on("individualChange", handelFileChange);
         this.on("groupAttrChange", handelFileChange);
         this.on("rangeAttrChange", handelFileChange);
         this.on("labelAttrChange", handelFileChange);
         this.on("behaviorAttrChange", handelFileChange);
+        this.on("clipAttrChange", handelFileChange);
         this.on("fileChange", () => this.archive.emit("fileChange"));
     }
 
@@ -284,6 +291,18 @@ class Status extends Emitter<IStatusEvent> {
         }
     }
 
+    /**
+     * 修改剪辑属性
+     */
+    public changeClipAttrib<K extends keyof Clip>
+    (id: ObjectID, key: K, val: Clip[K]) {
+        const clip = this.model.getClipById(id);
+        if (clip && clip instanceof Clip) {
+            clip[key] = val;
+            this.emit("clipAttrChange");
+        }
+    }
+
     public addGroupBehavior(id: ObjectID, val: Behavior) {
         const group = this.model.getObjectById(id);
         if (group && group instanceof Group) {
@@ -424,7 +443,7 @@ class Status extends Emitter<IStatusEvent> {
         return label;
     }
 
-    public newClip() {
+    public getNewClipName() {
         let searchKey = I18N(this.setting.language, "Object.List.New.Clip", { id: "" });
         let nextIndex = 1;
         this.model.clipPool.forEach((obj) => {
@@ -432,11 +451,13 @@ class Status extends Emitter<IStatusEvent> {
                 obj.name, searchKey
             ));
         });
-        const clip = this.model.addClip(
-            I18N(this.setting.language, "Object.List.New.Clip", {
+        return I18N(this.setting.language, "Object.List.New.Clip", {
             id: nextIndex.toString()
-            })
-        );
+        });
+    }
+
+    public newClip() {
+        const clip = this.model.addClip(this.getNewClipName());
         return clip;
     }
 

source/Localization/EN-US.ts

@@ -1,6 +1,10 @@
 const EN_US = {
+    "Language": "Language",
     "EN_US": "English (US)",
     "ZH_CN": "Chinese (Simplified)",
+    "Themes": "Themes",
+    "Themes.Dark": "Dark",
+    "Themes.Light": "Light",
     "Header.Bar.Title": "Living Together | Emulator",
     "Header.Bar.Title.Info": "Group Behavior Research Emulator",
     "Header.Bar.File.Name.Info": "{file} ({status})",
@@ -56,6 +60,8 @@ const EN_US = {
     "Panel.Info.Behavior.Details.View": "Edit view Behavior attributes",
     "Panel.Title.Behavior.Clip.Player": "Recording",
     "Panel.Info.Behavior.Clip.Player": "Pre render recorded data",
+    "Panel.Title.Behavior.Clip.Details": "Clip",
+    "Panel.Info.Behavior.Clip.Details": "Edit view clip attributes",
     "Panel.Info.Behavior.Clip.Time.Formate": "{current} / {all} / {fps}fps",
     "Panel.Info.Behavior.Clip.Record.Formate": "Record: {time}",
     "Panel.Info.Behavior.Clip.Uname.Clip": "Waiting for recording...",
@@ -72,6 +78,16 @@ const EN_US = {
     "Popup.Delete.Clip.Confirm": "Are you sure you want to delete this clip? The clip cannot be restored after deletion.",
     "Popup.Restore.Behavior.Confirm": "Are you sure you want to reset all parameters of this behavior? This operation cannot be recalled.",
     "Popup.Setting.Title": "Preferences setting",
+    "Popup.Offline.Render.Title": "Offline rendering",
+    "Popup.Offline.Render.Process.Title": "Rendering progress",
+    "Popup.Offline.Render.Message": "Rendering Parameters",
+    "Popup.Offline.Render.Input.Name": "Clip name",
+    "Popup.Offline.Render.Input.Time": "Duration (s)",
+    "Popup.Offline.Render.Input.Fps": "FPS (f/s)",
+    "Popup.Offline.Render.Input.Start": "Start rendering",
+    "Popup.Offline.Render.Input.End": "Terminate rendering",
+    "Popup.Offline.Render.Input.Finished": "Finished",
+    "Popup.Offline.Render.Process": "Number of frames completed: {current} / {all}",
     "Popup.Load.Save.Title": "Load save",
     "Popup.Load.Save.confirm": "Got it",
     "Popup.Load.Save.Overwrite": "Overwrite and continue",
@@ -151,6 +167,7 @@ const EN_US = {
     "Panel.Info.Behavior.Details.Parameter.Key.Vec.Y": "{key} Y",
     "Panel.Info.Behavior.Details.Parameter.Key.Vec.Z": "{key} Z",
     "Panel.Info.Clip.List.Error.Nodata": "There is no clip, please click the record button to record, or click the plus sign to create",
+    "Panel.Info.Clip.Details.Error.Nodata": "Specify a clip to view an attribute",
     "Info.Hint.Save.After.Close": "Any unsaved progress will be lost. Are you sure you want to continue?",
     "Info.Hint.Load.File.Title": "Load save",
     "Info.Hint.Load.File.Intro": "Release to load the dragged save file",

source/Localization/ZH-CN.ts

@@ -1,6 +1,10 @@
 const ZH_CN = {
+    "Language": "语言",
     "EN_US": "英语 (美国)",
     "ZH_CN": "中文 (简体)",
+    "Themes": "主题",
+    "Themes.Dark": "黑暗",
+    "Themes.Light": "亮色",
     "Header.Bar.Title": "群生共进 | 仿真器",
     "Header.Bar.Title.Info": "群体行为研究仿真器",
     "Header.Bar.File.Name.Info": "{file} ({status})",
@@ -56,6 +60,8 @@ const ZH_CN = {
     "Panel.Info.Behavior.Details.View": "编辑查看行为属性",
     "Panel.Title.Behavior.Clip.Player": "录制",
     "Panel.Info.Behavior.Clip.Player": "预渲染录制数据",
+    "Panel.Title.Behavior.Clip.Details": "剪辑",
+    "Panel.Info.Behavior.Clip.Details": "编辑查看剪辑片段属性",
     "Panel.Info.Behavior.Clip.Time.Formate": "{current} / {all} / {fps} fps",
     "Panel.Info.Behavior.Clip.Record.Formate": "录制: {time}",
     "Panel.Info.Behavior.Clip.Uname.Clip": "等待录制...",
@@ -72,6 +78,16 @@ const ZH_CN = {
     "Popup.Delete.Clip.Confirm": "你确定删除这个剪辑片段，剪辑片段删除后将无法恢复。",
     "Popup.Restore.Behavior.Confirm": "你确定要重置此行为的全部参数吗？此操作无法撤回。",
     "Popup.Setting.Title": "首选项设置",
+    "Popup.Offline.Render.Title": "离线渲染",
+    "Popup.Offline.Render.Process.Title": "渲染进度",
+    "Popup.Offline.Render.Message": "渲染参数",
+    "Popup.Offline.Render.Input.Name": "剪辑名称",
+    "Popup.Offline.Render.Input.Time": "时长 (s)",
+    "Popup.Offline.Render.Input.Fps": "帧率 (f/s)",
+    "Popup.Offline.Render.Input.Start": "开始渲染",
+    "Popup.Offline.Render.Input.End": "终止渲染",
+    "Popup.Offline.Render.Input.Finished": "完成",
+    "Popup.Offline.Render.Process": "完成帧数: {current} / {all}",
     "Popup.Load.Save.Title": "加载存档",
     "Popup.Load.Save.confirm": "我知道了",
     "Popup.Load.Save.Overwrite": "覆盖并继续",
@@ -151,6 +167,7 @@ const ZH_CN = {
     "Panel.Info.Behavior.Details.Parameter.Key.Vec.Y": "{key} Y 坐标",
     "Panel.Info.Behavior.Details.Parameter.Key.Vec.Z": "{key} Z 坐标",
     "Panel.Info.Clip.List.Error.Nodata": "没有剪辑片段，请点击录制按钮录制，或者点击加号创建",
+    "Panel.Info.Clip.Details.Error.Nodata": "请指定一个剪辑片段以查看属性",
     "Info.Hint.Save.After.Close": "任何未保存的进度都会丢失, 确定要继续吗?",
     "Info.Hint.Load.File.Title": "加载存档",
     "Info.Hint.Load.File.Intro": "释放以加载拽入的存档",

source/Model/Actuator.ts

@@ -13,6 +13,7 @@ interface IActuatorEvent {
 	startChange: boolean;
 	record: number;
 	loop: number;
+	offline: number;
 }
 
 /**
@@ -217,6 +218,124 @@ class Actuator extends Emitter<IActuatorEvent> {
 
 	private playTickerTimer?: number;
 
+	/**
+	 * 设置播放进度
+	 */
+	public setPlayProcess(id: number) {
+		if (this.playClip && id >= 0 && id < this.playClip.frames.length) {
+		
+			// 跳转值这帧
+			this.playFrameId = id;
+			this.playFrame = this.playClip.frames[this.playFrameId];
+			this.emit("record", this.playFrame.duration);
+
+			if (this.mod !== ActuatorModel.Play) {
+				this.playClip.play(this.playFrame);
+			}
+		}
+	}
+
+	/**
+	 * 离线渲染参数
+	 */
+	public offlineAllFrame: number = 0;
+	public offlineCurrentFrame: number = 0;
+	private offlineRenderTickTimer?: number;
+
+	/**
+	 * 关闭离线渲染
+	 */
+	public endOfflineRender() {
+
+		// 清除 timer
+		clearTimeout(this.offlineRenderTickTimer);
+
+		this.recordClip && (this.recordClip.isRecording = false);
+		this.recordClip = undefined;
+		
+		// 设置状态
+		this.mod = ActuatorModel.View;
+
+		// 激发结束事件
+		this.start(false);
+		this.emit("record", 0);
+	}
+
+	/**
+	 * 离线渲染 tick
+	 */
+	private offlineRenderTick(dt: number) {
+
+		if (this.mod !== ActuatorModel.Offline) {
+			return;
+		}
+
+		if (this.offlineCurrentFrame >= this.offlineAllFrame) {
+			return this.endOfflineRender();
+		}
+		
+		// 更新模型
+		this.model.update(dt);
+
+		// 录制
+		this.recordClip?.record(dt);
+
+		// 限制更新频率
+		if (this.offlineCurrentFrame % 10 === 0) {
+			this.emit("offline", dt);
+		}
+
+		this.offlineCurrentFrame++
+
+		if (this.offlineCurrentFrame <= this.offlineAllFrame) {
+			
+			// 下一个 tick
+			this.offlineRenderTickTimer = setTimeout(() => this.offlineRenderTick(dt)) as any;
+
+		} else {
+			this.endOfflineRender();
+		}
+	}
+
+	/**
+	 * 离线渲染
+	 */
+	public offlineRender(clip: Clip, time: number, fps: number) {
+		
+		// 记录录制片段
+		this.recordClip = clip;
+		clip.isRecording = true;
+
+		// 如果仿真正在进行，停止仿真
+		if (this.start()) this.start(false);
+
+		// 如果正在录制，阻止
+		if (this.mod === ActuatorModel.Record || this.mod === ActuatorModel.Offline) {
+			return;
+		}
+
+		// 如果正在播放，暂停播放
+		if (this.mod === ActuatorModel.Play) {
+			this.pausePlay();
+		}
+
+		// 设置状态
+		this.mod = ActuatorModel.Offline;
+
+		// 计算帧数
+		this.offlineCurrentFrame = 0;
+		this.offlineAllFrame = Math.round(time * fps) - 1;
+		let dt = time / this.offlineAllFrame;
+
+		// 第一帧渲染
+		clip.record(0);
+
+		// 开启时钟
+		this.offlineRenderTick(dt);
+
+		this.emit("record", dt);
+	}
+
 	/**
 	 * 播放时钟
 	 */

source/Model/Archive.ts

@@ -8,6 +8,7 @@ import { IArchiveIndividual, Individual } from "@Model/Individual";
 import { Behavior, IArchiveBehavior } from "@Model/Behavior";
 import { getBehaviorById } from "@Behavior/Behavior";
 import { IArchiveParseFn, IObjectParamArchiveType, IRealObjectType } from "@Model/Parameter";
+import { Clip, IArchiveClip } from "@Model/Clip";
 
 interface IArchiveEvent {
     fileSave: Archive;
@@ -20,6 +21,7 @@ interface IArchiveObject {
     objectPool: IArchiveCtrlObject[];
     labelPool: IArchiveLabel[];
     behaviorPool: IArchiveBehavior[];
+    clipPool: IArchiveClip[];
 }
 
 class Archive extends Emitter<IArchiveEvent> {
@@ -51,7 +53,7 @@ class Archive extends Emitter<IArchiveEvent> {
 
         // 存贮 CtrlObject
         const objectPool: IArchiveCtrlObject[] = [];
-        model.objectPool.forEach(obj => {
+        model.objectPool?.forEach(obj => {
             let archiveObject = obj.toArchive();
 
             // 处理每个群的个体
@@ -60,7 +62,7 @@ class Archive extends Emitter<IArchiveEvent> {
                 const group: Group = obj as Group;
 
                 const individuals: IArchiveIndividual[] = [];
-                group.individuals.forEach((item) => {
+                group.individuals?.forEach((item) => {
                     individuals.push(item.toArchive());
                 });
 
@@ -72,22 +74,29 @@ class Archive extends Emitter<IArchiveEvent> {
 
         // 存储 Label
         const labelPool: IArchiveLabel[] = [];
-        model.labelPool.forEach(obj => {
+        model.labelPool?.forEach(obj => {
             labelPool.push(obj.toArchive());
         });
 
         // 存储全部行为
         const behaviorPool: IArchiveBehavior[] = [];
-        model.behaviorPool.forEach(obj => {
+        model.behaviorPool?.forEach(obj => {
             behaviorPool.push(obj.toArchive());
         });
 
+        // 存储全部剪辑片段
+        const clipPool: IArchiveClip[] = [];
+        model.clipPool?.forEach(obj => {
+            clipPool.push(obj.toArchive());
+        });
+
         // 生成存档对象
         const fileData: IArchiveObject = {
             nextIndividualId: model.nextIndividualId,
             objectPool: objectPool,
             labelPool: labelPool,
-            behaviorPool: behaviorPool
+            behaviorPool: behaviorPool,
+            clipPool: clipPool
         };
 
         return JSON.stringify(fileData);
@@ -105,7 +114,7 @@ class Archive extends Emitter<IArchiveEvent> {
         // 实例化全部对象
         const objectPool: CtrlObject[] = [];
         const individualPool: Individual[] = [];
-        archive.objectPool.forEach((obj) => {
+        archive.objectPool?.forEach((obj) => {
 
             let ctrlObject: CtrlObject | undefined = undefined;
             
@@ -116,7 +125,7 @@ class Archive extends Emitter<IArchiveEvent> {
 
                 // 实例化全部个体
                 const individuals: Array<Individual> = [];
-                archiveGroup.individuals.forEach((item) => {
+                archiveGroup.individuals?.forEach((item) => {
                     const newIndividual = new Individual(newGroup);
                     newIndividual.id = item.id;
                     individuals.push(newIndividual);
@@ -140,7 +149,7 @@ class Archive extends Emitter<IArchiveEvent> {
 
         // 实例化全部标签
         const labelPool: Label[] = [];
-        archive.labelPool.forEach((item) => {
+        archive.labelPool?.forEach((item) => {
             const newLabel = new Label(model);
             newLabel.id = item.id;
             labelPool.push(newLabel);
@@ -148,13 +157,21 @@ class Archive extends Emitter<IArchiveEvent> {
 
         // 实例化全部行为
         const behaviorPool: Behavior[] = [];
-        archive.behaviorPool.forEach((item) => {
+        archive.behaviorPool?.forEach((item) => {
             const recorder = getBehaviorById(item.behaviorId);
             const newBehavior = recorder.new();
             newBehavior.id = item.id;
             behaviorPool.push(newBehavior);
         });
 
+        // 实例化全部剪辑
+        const clipPool: Clip[] = [];
+        archive.clipPool?.forEach((item) => {
+            const newClip = new Clip(model);
+            newClip.id = item.id;
+            clipPool.push(newClip);
+        });
+
         // 内置标签集合
         const buildInLabel = [model.allGroupLabel, model.allRangeLabel, model.currentGroupLabel]
 
@@ -238,6 +255,12 @@ class Archive extends Emitter<IArchiveEvent> {
             item.fromArchive(archive.behaviorPool[index], parseFunction);
             return item;
         });
+
+        // 加载剪辑
+        model.clipPool = clipPool.map((item, index) => {
+            item.fromArchive(archive.clipPool[index], parseFunction);
+            return item;
+        });
     }
 
     /**
@@ -278,4 +301,4 @@ class Archive extends Emitter<IArchiveEvent> {
     }
 }
 
-export { Archive };
+export { Archive, IArchiveObject };

source/Model/Clip.ts

@@ -2,11 +2,14 @@ import { IAnyObject, Model } from "@Model/Model";
 import { v4 as uuid } from "uuid";
 import { Group } from "@Model/Group";
 import { Range } from "@Model/Range";
+import { archiveObject2Parameter, IArchiveParseFn, parameter2ArchiveObject } from "@Model/Parameter";
 
 interface IDrawCommand {
 	type: "points" | "cube";
 	id: string;
+	name?: string;
 	data?: Float32Array;
+	mapId?: number[];
 	position?: number[];
 	radius?: number[];
 	parameter?: IAnyObject;
@@ -18,6 +21,13 @@ interface IFrame {
 	process: number;
 }
 
+interface IArchiveClip {
+	id: string;
+	time: number;
+	name: string;
+	frames: IFrame[];
+}
+
 /**
  * 剪辑片段
  */
@@ -50,6 +60,147 @@ class Clip {
 	 */
 	public isRecording: boolean = false;
 
+	/**
+	 * 判断两个 RenderParameter 是否相同
+	 */
+	public isRenderParameterEqual(p1?: IAnyObject, p2?: IAnyObject, r: boolean = true): boolean {
+
+		if ((p1 && !p2) || (!p1 && p2)) {
+			return false;
+		}
+
+		if (!p1 && !p2) {
+			return true;
+		}
+
+		for (let key in p1!) {
+
+			// 对象递归校验
+			if (typeof p1[key] === "object" && !Array.isArray(p1[key])) {
+
+				if (!(typeof (p2 as any)[key] === "object" && !Array.isArray((p2 as any)[key]))) {
+					return false;
+				}
+
+				// 递归校验
+				if (r) {
+					if (!this.isRenderParameterEqual(p1[key], (p2 as any)[key], false)) {
+						return false;
+					}
+				}
+				
+				// 浅校验
+				else {
+					if (p1[key] !== (p2 as any)[key]) {
+						return false;
+					}
+				}
+			}
+
+			// 数组遍历校验
+			else if (Array.isArray(p1[key])) {
+
+				if (!Array.isArray((p2 as any)[key])) {
+					return false;
+				}
+
+				for (let j = 0; j < p1[key].length; j++) {
+					if (p1[key][j] !== (p2 as any)[key][j]) {
+						return false;
+					}
+				}
+			}
+
+			// 数值直接校验
+			else if (p1[key] !== (p2 as any)[key]) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	public cloneRenderParameter(p?: IAnyObject, res: IAnyObject = {}, r: boolean = true): IAnyObject | undefined {
+
+		if (!p) return undefined;
+
+		for (let key in p) {
+
+			// 对象递归克隆
+			if (typeof p[key] === "object" && !Array.isArray(p[key]) && r) {
+				this.cloneRenderParameter(p[key], res, false);
+			}
+
+			// 数组克隆
+			else if (Array.isArray(p[key])) {
+				(res as any)[key] = p[key].concat([]);
+			}
+
+			// 数值克隆
+			else {
+				(res as any)[key] = p[key];
+			}
+		}
+
+		return res;
+	}
+
+	public isArrayEqual(a1?: Array<number | string>, a2?: Array<number | string>): boolean {
+
+		if ((a1 && !a2) || (!a1 && a2)) {
+			return false;
+		}
+
+		if (!a1 && !a2) {
+			return true;
+		}
+
+		for (let i = 0; i < a1!.length; i++) {
+			if (a1![i] !== a2![i]) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * 从上一帧获取指令数据
+	 */
+	public getCommandFromLastFrame(type: IDrawCommand["type"], id: string, frame?: IFrame): IDrawCommand | undefined {
+		let lastCommand: IDrawCommand[] = (frame ?? this.frames[this.frames.length - 1])?.commands;
+
+		if (lastCommand) {
+			for (let i = 0; i < lastCommand.length; i++) {
+				if (type === lastCommand[i].type && id === lastCommand[i].id) {
+					return lastCommand[i];
+				}
+			}
+		}
+
+		return undefined;
+	}
+
+	/**
+	 * ID 映射
+	 */
+	private sorterIdMapper: Map<string, number> = new Map();
+	private sorterIdMapperNextId: number = 1;
+
+	/**
+	 * 获取映射ID
+	 */
+	private getMapperId = (id: string): number => {
+		let mapperId = this.sorterIdMapper.get(id);
+		if (mapperId === undefined) {
+			mapperId = this.sorterIdMapperNextId ++;
+			this.sorterIdMapper.set(id, mapperId);
+			return mapperId;
+		} else {
+			return mapperId;
+		}
+	}
+
 	/**
 	 * 录制一帧
 	 */
@@ -62,23 +213,68 @@ class Clip {
             object.renderParameter.color = object.color;
 
             if (object.display && object instanceof Group) {
-				commands.push({
+
+				// 获取上一帧指令
+				const lastCommand = this.getCommandFromLastFrame("points", object.id);
+
+				// 记录
+				const dataBuffer = object.exportPositionId(this.getMapperId);
+				const recodeData: IDrawCommand = {
 					type: "points",
 					id: object.id,
-					data: object.exportPositionData(),
-					parameter: object.renderParameter
-				});
+					name: object.displayName,
+					data: dataBuffer[0]
+				}
+
+				// 对比校验
+				if (this.isRenderParameterEqual(object.renderParameter, lastCommand?.parameter)) {
+					recodeData.parameter = lastCommand?.parameter;
+				} else {
+					recodeData.parameter = this.cloneRenderParameter(object.renderParameter);
+				}
+
+				if (this.isArrayEqual(dataBuffer[1], lastCommand?.mapId)) {
+					recodeData.mapId = lastCommand?.mapId;
+				} else {
+					recodeData.mapId = dataBuffer[1];
+				}
+
+				commands.push(recodeData);
             }
 
 
             if (object.display && object instanceof Range) {
-				commands.push({
+
+				// 获取上一帧指令
+				const lastCommand = this.getCommandFromLastFrame("cube", object.id);
+
+				// 记录
+				const recodeData: IDrawCommand = {
 					type: "cube",
 					id: object.id,
-					position: object.position,
-					radius: object.radius,
-					parameter: object.renderParameter
-				});
+					name: object.displayName
+				}
+
+				// 释放上一帧的内存
+				if (this.isArrayEqual(object.position, lastCommand?.position)) {
+					recodeData.position = lastCommand?.position;
+				} else {
+					recodeData.position = object.position.concat([]);
+				}
+
+				if (this.isArrayEqual(object.radius, lastCommand?.radius)) {
+					recodeData.radius = lastCommand?.radius;
+				} else {
+					recodeData.radius = object.radius.concat([]);
+				}
+
+				if (this.isRenderParameterEqual(object.renderParameter, lastCommand?.parameter)) {
+					recodeData.parameter = lastCommand?.parameter;
+				} else {
+					recodeData.parameter = this.cloneRenderParameter(object.renderParameter);
+				}
+
+				commands.push(recodeData);
             }
         }
 
@@ -95,6 +291,120 @@ class Clip {
 		return frame;
 	}
 
+	public readonly LastFrameData: "@" = "@";
+
+	/**
+	 * 压缩帧数据
+	 */
+	public compressed(): IFrame[] {
+		const resFrame: IFrame[] = [];
+
+		for (let i = 0; i < this.frames.length; i++) {
+			const commands = this.frames[i].commands;
+			const res: IDrawCommand[] = [];
+
+			// 处理指令
+			for (let j = 0; j < commands.length; j++) {
+				
+				// 压缩指令
+				const command: IDrawCommand = {
+					id: commands[j].id,
+					type: commands[j].type
+				};
+
+				// 搜索上一帧相同指令
+				const lastCommand = this.frames[i - 1] ?
+					this.getCommandFromLastFrame(command.type, command.id, this.frames[i - 1]) :
+					undefined;
+
+				// 记录
+				command.name = (lastCommand?.name === commands[j].name) ?
+					this.LastFrameData as any : commands[j].name;
+
+				command.data = (lastCommand?.data === commands[j].data) ?
+					this.LastFrameData as any : Array.from(commands[j].data ?? []);
+
+				command.mapId = (lastCommand?.mapId === commands[j].mapId) ?
+					this.LastFrameData as any : commands[j].mapId;
+
+				command.position = (lastCommand?.position === commands[j].position) ?
+					this.LastFrameData as any : commands[j].position?.concat([]);
+
+				command.radius = (lastCommand?.radius === commands[j].radius) ?
+					this.LastFrameData as any : commands[j].radius?.concat([]);
+
+				command.parameter = (lastCommand?.parameter === commands[j].parameter) ?
+					this.LastFrameData as any : parameter2ArchiveObject(commands[j].parameter as any);
+
+				res.push(command);
+			}
+
+			resFrame.push({
+				duration: this.frames[i].duration,
+				process: this.frames[i].process,
+				commands: res
+			})
+		}
+
+		return resFrame;
+	};
+
+	/**
+	 * 加载压缩帧数据
+	 */
+	public uncompressed(frames: IFrame[], paster: IArchiveParseFn): IFrame[] {
+		const resFrame: IFrame[] = [];
+
+		for (let i = 0; i < frames.length; i++) {
+			const commands = frames[i].commands;
+			const res: IDrawCommand[] = [];
+
+			// 处理指令
+			for (let j = 0; j < commands.length; j++) {
+				
+				// 压缩指令
+				const command: IDrawCommand = {
+					id: commands[j].id,
+					type: commands[j].type
+				};
+
+				// 搜索上一帧相同指令
+				const lastCommand = resFrame[resFrame.length - 1] ?
+					this.getCommandFromLastFrame(command.type, command.id, resFrame[resFrame.length - 1]) :
+					undefined;
+
+				// 记录
+				command.name = (this.LastFrameData as any === commands[j].name) ?
+					lastCommand?.name : commands[j].name;
+				
+				command.data = (this.LastFrameData as any === commands[j].data) ?
+					lastCommand?.data : new Float32Array(commands[j].data ?? []);
+
+				command.mapId = (this.LastFrameData as any === commands[j].mapId) ?
+					lastCommand?.mapId : commands[j].mapId;
+
+				command.position = (this.LastFrameData as any === commands[j].position) ?
+					lastCommand?.position : commands[j].position;
+
+				command.radius = (this.LastFrameData as any === commands[j].radius) ?
+					lastCommand?.radius : commands[j].radius;
+
+				command.parameter = (this.LastFrameData as any === commands[j].parameter) ?
+					lastCommand?.parameter : archiveObject2Parameter(commands[j].parameter as any, paster);
+
+				res.push(command);
+			}
+
+			resFrame.push({
+				duration: frames[i].duration,
+				process: frames[i].process,
+				commands: res
+			})
+		}
+
+		return resFrame;
+	}
+
 	/**
 	 * 播放一帧
 	 */
@@ -125,6 +435,22 @@ class Clip {
 		this.model = model;
 		this.id = uuid();
 	}
+
+	public toArchive(): IArchiveClip {
+        return {
+            id: this.id,
+			time: this.time,
+			name: this.name,
+			frames: this.compressed()
+        };
+    }
+
+    public fromArchive(archive: IArchiveClip, paster: IArchiveParseFn): void {
+        this.id = archive.id,
+		this.time = archive.time,
+		this.name = archive.name,
+		this.frames = this.uncompressed(archive.frames, paster);
+    }
 }
 
-export { Clip, IFrame };
+export { Clip, IFrame, IArchiveClip };

source/Model/Group.ts

@@ -428,6 +428,22 @@ class Group extends CtrlObject<IArchiveGroup> {
         return dataBuffer;
     }
 
+    /**
+     * 导出个体id列表
+     */
+    public exportPositionId(idMapper: (id: string) => number ): [Float32Array, number[]] {
+        let bi = 0; let ii = 0;
+        let dataBuffer = new Float32Array(this.individuals.size * 3);
+        let idBUffer: number[] = new Array(this.individuals.size).fill("");
+        this.individuals.forEach((individual) => {
+            idBUffer[ii ++] = idMapper(individual.id);
+            dataBuffer[bi ++] = individual.position[0];
+            dataBuffer[bi ++] = individual.position[1];
+            dataBuffer[bi ++] = individual.position[2];
+        });
+        return [dataBuffer, idBUffer];
+    }
+
     public override toArchive(): IArchiveCtrlObject & IArchiveGroup {
         return {
             ...super.toArchive(),

source/Model/Model.ts

@@ -349,6 +349,14 @@ class Model extends Emitter<ModelEvent> {
         return newClip;
     }
 
+    public getClipById(id: ObjectID): Clip | undefined {
+        for (let i = 0; i < this.clipPool.length; i++) {
+            if (this.clipPool[i].id.toString() === id.toString()) {
+                return this.clipPool[i];
+            }
+        }
+    }
+
     /**
      * 删除一个剪辑片段
      */

source/Page/SimulatorDesktop/SimulatorDesktop.tsx

@@ -64,7 +64,7 @@ class SimulatorDesktop extends Component {
                     items: [
                         {panels: ["RenderView"]},
                         {
-                            items: [{panels: ["BehaviorList"]}, {panels: ["LabelList"]}],
+                            items: [{panels: ["BehaviorList", "ClipPlayer"]}, {panels: ["LabelList"]}],
                             scale: 80,
                             layout: LayoutDirection.X
                         }
@@ -76,7 +76,7 @@ class SimulatorDesktop extends Component {
                     items: [{
                         panels: ["ObjectList"]
                     }, {
-                        panels: ["GroupDetails", "RangeDetails", "LabelDetails", "BehaviorDetails"]
+                        panels: ["GroupDetails", "RangeDetails", "LabelDetails", "BehaviorDetails", "ClipDetails"]
                     }],
                     scale: 30,
                     layout: LayoutDirection.Y

source/Page/SimulatorWeb/SimulatorWeb.tsx

@@ -55,7 +55,7 @@ class SimulatorWeb extends Component {
                     items: [
                         {panels: ["RenderView"]},
                         {
-                            items: [{panels: ["ClipPlayer", "BehaviorList"]}, {panels: ["LabelList"]}],
+                            items: [{panels: ["BehaviorList", "ClipPlayer"]}, {panels: ["LabelList"]}],
                             scale: 80,
                             layout: LayoutDirection.X
                         }
@@ -67,7 +67,7 @@ class SimulatorWeb extends Component {
                     items: [{
                         panels: ["ObjectList"]
                     }, {
-                        panels: ["GroupDetails", "RangeDetails", "LabelDetails", "BehaviorDetails"]
+                        panels: ["GroupDetails", "RangeDetails", "LabelDetails", "BehaviorDetails", "ClipDetails"]
                     }],
                     scale: 30,
                     layout: LayoutDirection.Y

source/Panel/ClipDetails/ClipDetails.tsx

@@ -0,0 +1,60 @@
+import { Component, ReactNode } from "react";
+import { useStatusWithEvent, IMixinStatusProps } from "@Context/Status";
+import { TogglesInput } from "@Input/TogglesInput/TogglesInput";
+import { ConfirmPopup } from "@Component/ConfirmPopup/ConfirmPopup";
+import { AttrInput } from "@Input/AttrInput/AttrInput";
+import { Message } from "@Input/Message/Message";
+import { Clip } from "@Model/Clip";
+import "./ClipDetails.scss";
+
+@useStatusWithEvent("focusClipChange", "clipAttrChange")
+class ClipDetails extends Component<IMixinStatusProps> {
+
+    private renderFrom(clip: Clip) {
+        return <>
+
+            <Message i18nKey="Common.Attr.Title.Basic" isTitle first/>
+            
+            <AttrInput
+                keyI18n="Common.Attr.Key.Display.Name"
+                maxLength={15}
+                value={clip.name}
+                valueChange={(value) => {
+                    if (this.props.status) {
+                        this.props.status.changeClipAttrib(clip.id, "name", value);
+                    }
+                }}
+            />
+
+            <TogglesInput
+                keyI18n="Common.Attr.Key.Delete" onIconName="delete" red
+                offIconName="delete" valueChange={() => {
+                    const status = this.props.status;
+                    if (status) {
+                        status.popup.showPopup(ConfirmPopup, {
+                            infoI18n: "Popup.Delete.Clip.Confirm",
+                            titleI18N: "Popup.Action.Objects.Confirm.Title",
+                            yesI18n: "Popup.Action.Objects.Confirm.Delete",
+                            red: "yes",
+                            yes: () => {
+                                status.setClipObject();
+                                this.props.status?.actuator.endPlay();
+                                status.model.deleteClip(clip.id);
+                            }
+                        });
+                    }
+                }}
+            />
+
+		</>;
+    }
+
+	public render(): ReactNode {
+        if (this.props.status && this.props.status.focusClip) {
+            return this.renderFrom(this.props.status.focusClip);
+        }
+		return <Message i18nKey="Panel.Info.Clip.Details.Error.Nodata"/>;
+	}
+}
+
+export { ClipDetails };

source/Panel/ClipPlayer/ClipPlayer.tsx

@@ -1,15 +1,18 @@
 import { Component, ReactNode } from "react";
 import { ClipList } from "@Component/ClipList/ClipList";
 import { useStatusWithEvent, IMixinStatusProps } from "@Context/Status";
+import { useSetting, IMixinSettingProps } from "@Context/Setting";
 import { BackgroundLevel, FontLevel, Theme } from "@Component/Theme/Theme";
 import { Message } from "@Input/Message/Message";
 import { Clip } from "@Model/Clip";
 import { ActuatorModel } from "@Model/Actuator";
 import { ConfirmPopup } from "@Component/ConfirmPopup/ConfirmPopup";
+import { OfflineRender } from "@Component/OfflineRender/OfflineRender"
 import "./ClipPlayer.scss";
 
-@useStatusWithEvent("clipChange", "focusClipChange", "actuatorStartChange")
-class ClipPlayer extends Component<IMixinStatusProps> {
+@useSetting
+@useStatusWithEvent("clipChange", "focusClipChange", "actuatorStartChange", "clipAttrChange")
+class ClipPlayer extends Component<IMixinStatusProps & IMixinSettingProps> {
 
 	private isInnerClick: boolean = false;
 
@@ -50,11 +53,13 @@ class ClipPlayer extends Component<IMixinStatusProps> {
 			}}
 			add={() => {
 				this.isInnerClick = true;
+				this.props.status?.popup.showPopup(OfflineRender, {});
 			}}
 			click={(clip) => {
 				this.isInnerClick = true;
 				this.props.status?.setClipObject(clip);
 				this.props.status?.actuator.startPlay(clip);
+				this.props.setting?.layout.focus("ClipDetails");
 			}}
 		/>;
 	}

source/Panel/ClipPlayer/ClipRecorder.tsx

@@ -3,7 +3,7 @@ import { useStatusWithEvent, IMixinStatusProps } from "@Context/Status";
 import { Recorder } from "@Component/Recorder/Recorder";
 import { ActuatorModel } from "@Model/Actuator";
 
-@useStatusWithEvent("actuatorStartChange", "focusClipChange", "recordLoop")
+@useStatusWithEvent("actuatorStartChange", "focusClipChange", "recordLoop", "clipAttrChange")
 class ClipRecorder extends Component<IMixinStatusProps> {
 	public render(): ReactNode {
 
@@ -90,9 +90,12 @@ class ClipRecorder extends Component<IMixinStatusProps> {
 
 					// 启动播放时钟
 					this.props.status?.actuator.pausePlay();
-					console.log("ClipRecorder: Pause start...");
+					console.log("ClipRecorder: Pause play...");
 				}
 			}}
+			valueChange={(value) => {
+				this.props.status?.actuator.setPlayProcess(value);
+			}}
 		/>
 	}
 }

source/Panel/Panel.tsx

@@ -12,6 +12,7 @@ import { BehaviorList } from "@Panel/BehaviorList/BehaviorList";
 import { BehaviorDetails } from "@Panel/BehaviorDetails/BehaviorDetails";
 import { ClipPlayer } from "@Panel/ClipPlayer/ClipPlayer";
 import { ClipRecorder } from "@Panel/ClipPlayer/ClipRecorder";
+import { ClipDetails } from "@Panel/ClipDetails/ClipDetails";
 
 interface IPanelInfo {
 	nameKey: string;
@@ -34,6 +35,7 @@ type PanelId = ""
 | "BehaviorList" // 行为列表
 | "BehaviorDetails" // 行为属性
 | "ClipPlayer" // 剪辑影片
+| "ClipDetails" // 剪辑详情
 ;
 
 const PanelInfoMap = new Map<PanelId, IPanelInfo>();
@@ -73,6 +75,10 @@ PanelInfoMap.set("ClipPlayer", {
     nameKey: "Panel.Title.Behavior.Clip.Player", introKay: "Panel.Info.Behavior.Clip.Player",
     class: ClipPlayer, header: ClipRecorder, hidePadding: true
 });
+PanelInfoMap.set("ClipDetails", {
+    nameKey: "Panel.Title.Behavior.Clip.Details", introKay: "Panel.Info.Behavior.Clip.Details",
+    class: ClipDetails
+});
 
 function getPanelById(panelId: PanelId): ReactNode {
 	switch (panelId) {