@cc-component/cc-core 1.2.8

package/assets/core/home/InViewCenter.ts

@@ -0,0 +1,52 @@
+import { _decorator, Camera, Component, find, Node, Vec3, view } from 'cc';
+const { ccclass, property } = _decorator;
+
+export class InViewCenter {
+    private _lastWPos: Vec3 = new Vec3();
+    private _pos: Vec3 = new Vec3();
+    screenSize: any;
+    height = 0
+    width = 0
+    camera: Camera;
+    canvasView: Node;
+
+    constructor() {
+        this.InitView()
+    }
+
+    InitView() {
+        this.canvasView = find("Home");
+        this.camera = find('Camera').getComponent(Camera)
+        this.screenSize = view.getVisibleSize();
+
+        this.height = 667//this.screenSize.height / 2;
+        this.width = this.screenSize.width / 2 + 130;
+    }
+
+    IsInView3D(wpos: Vec3) {
+        // @ts-ignore
+        if (!this.camera!._camera) {
+            return;
+        }
+        this._lastWPos.set(wpos);
+        const camera = this.camera!;
+        // [HACK]
+        // @ts-ignore
+        camera._camera.update();
+        camera.convertToUINode(wpos, this.canvasView, this._pos);
+        //  this.label.setPosition(this._pos);
+        const temp_pos = this._pos
+
+        const isInView = this.isPointInsideCanvas(temp_pos)//this.IsInView(this._pos)
+
+        return isInView;
+    }
+
+    isPointInsideCanvas(point: Vec3): boolean {
+        const canvasSize = this.screenSize;
+        //console.log(this.width)
+        return (point.x >= -this.width && point.x <= this.width &&
+            point.y >= -this.height && point.y <= this.height);
+    }
+}
+

package/assets/core/home/InViewCenter.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "cca892ef-33a8-4132-bc31-14534cfa126b",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/core/home/JsonUtil.ts

@@ -0,0 +1,102 @@
+import { assetManager } from "cc";
+import { JsonAsset, resources, AssetManager, director } from "cc";
+
+export class JsonUtil {
+
+    data: Map<string, any> = new Map();
+    dataMap: Map<string, any> = new Map();
+
+    static _instance: JsonUtil;
+    static get instance(): JsonUtil {
+        if (!this._instance) {
+            this._instance = new JsonUtil();
+        }
+        return this._instance;
+    }
+
+    static get(tabName: string) {
+        return JsonUtil.instance.data.get(tabName);
+    }
+
+    // static getMap<T>() {
+    //     const map = new Map<number, T>();
+    //     const data = JsonUtil.get(T.TableName)
+    //     for (const key in data) {
+    //         if (data.hasOwnProperty(key)) {
+    //             let id = parseInt(key);
+    //             map.set(id, new T(id))
+    //         }
+    //     }
+    //     return map;
+    // }
+
+    static getMap<T>(table_name: string, is_copy: boolean = false): Map<number, T> {
+        // 使用构造函数名称作为键值
+        const constructorName = table_name;
+        if (is_copy) {
+            return JSON.parse(JSON.stringify(JsonUtil.getMap(table_name, false)))
+        }
+        else if (JsonUtil.instance.dataMap.has(constructorName)) {
+            return JsonUtil.instance.dataMap.get(constructorName);
+        } else {
+            console.error('没有这个表', table_name)
+            return null;
+        }
+    }
+    async loadJsonAll(bundleName, path: string) {
+        if (!this.data.has(bundleName)) {
+            await this.loadAllJsonAssets(bundleName, path)
+        }
+    }
+
+    async loadLanguage(bundleName, path: string) {
+        await this.loadAllJsonAssets(bundleName, path)
+        const bundle: AssetManager.Bundle | null = assetManager.getBundle(bundleName);
+        console.error('json===', this.data)
+    }
+
+
+    /**
+     * 从指定的bundle中加载文件夹中的所有JsonAsset资源 (3.x语法)
+     * @param bundleName bundle名称
+     * @param path 文件夹路径（相对于bundle目录）
+     * @returns 返回Promise<JsonAsset[]>，包含文件夹中所有JSON资源
+     */
+    private loadAllJsonAssets(bundleName: string, path: string): Promise<Map<string, any>> {
+        return new Promise((resolve, reject) => {
+            const bundle: AssetManager.Bundle | null = assetManager.getBundle(bundleName);
+            if (bundle) {
+                bundle.loadDir(path, JsonAsset, (err: Error | null, assets: JsonAsset[]) => {
+                    if (err) {
+                        reject(err);
+                    } else {
+                        assets.forEach(asset => {
+                            this.data.set(asset.name, asset.json);
+                            const constructorName = `${asset.name}`
+                            const map = new Map<number, any>();
+                            const data = JsonUtil.get(constructorName);
+                            if (data) {
+                                for (const key in data) {
+                                    if (data.hasOwnProperty(key)) {
+                                        let id = parseInt(key);
+                                        data[key].id = id;
+                                        map.set(id, data[key]);
+                                    }
+                                }
+                            }
+                            JsonUtil.instance.dataMap.set(constructorName, map);
+                        });
+
+
+
+                        resolve(this.data);
+                    }
+                });
+            } else {
+                reject(new Error(`报错了 '${bundleName}' not found`));
+            }
+        });
+    }
+
+
+}

package/assets/core/home/JsonUtil.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "afbb49b0-2735-4364-a508-893fc085454b",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/core/home/LoadingWindow.ts

@@ -0,0 +1,44 @@
+import { _decorator, Component, find, Label, Node, Tween, tween, v3 } from 'cc';
+const { ccclass, property } = _decorator;
+
+@ccclass('LoadingWindow')
+export class LoadingWindow extends Component {
+
+    message: Label;
+    loadingSpin: Node
+    loadingSpin2: Node
+
+    protected onLoad(): void {
+        this.InitView()
+    }
+    InitView() {
+        this.message = find("root/Label", this.node).getComponent(Label);
+        this.loadingSpin = find("root/loadingSpin", this.node)
+        this.loadingSpin2 = find("root/Loading Wheel", this.node)
+        this.Show("")
+        this.node.active = false
+    }
+
+    Show(message: string) {
+        this.node.active = true;
+        this.StartAnim()
+        this.message.string = message === "" ? "加载中 请稍等..." : message;
+    }
+
+    Hide() {
+        Tween.stopAllByTarget(this.node)
+        this.node.active = false;
+    }
+
+
+    StartAnim() {
+        Tween.stopAllByTarget(this.node)
+        tween(this.loadingSpin)
+            .repeatForever(
+                tween().by(1, { eulerAngles: v3(0, 0, -360) }) // 每次旋转360度
+            )
+            .start();
+    }
+
+}
+

package/assets/core/home/LoadingWindow.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "39159e5b-86c8-4e73-8fb2-83cbeb71ba38",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/core/home/ParabolaTween.ts

@@ -0,0 +1,110 @@
+import { instantiate } from 'cc';
+import { randomRangeInt } from 'cc';
+import { _decorator, Component, misc, Node, tween, v3, Vec3 } from 'cc';
+const { ccclass, property } = _decorator;
+
+@ccclass('ParabolaTween')
+export class ParabolaTween {
+
+    /**
+     * 开始抛物线缓动
+     * @param item 运动节点
+     * @param target_postion 目标位置
+     * @param update 更新 运动中回调
+     * @param offset_ratio 最高点 的偏移量
+     * @param time 动画时间
+     * @param is_random 是否随机上下方向
+     * @param start_position 起始位置--比如 父节点的位置和 抛物线的起点位置 不同，，用父节点的起始位置就传入
+     */
+    RunParabolaTween(item: Node, target_postion: Vec3, update: (ratio: number) => void, param?: { offset_ratio?: number, is_random: boolean, time?: number, start_position?: Vec3,is_end_clone?:boolean }) {
+        const distance = Vec3.distance(target_postion, item.worldPosition)
+
+        const start = item.worldPosition.clone();
+        const end = target_postion
+
+
+        let fx = end.x >= (param?.start_position ? param?.start_position.x : start.x) ? 1 : -1;//朝向始终 是上抛物线，
+        if (param?.is_random) { fx = [-1, 1][randomRangeInt(0, 2)] }
+
+        const direction = end.clone().subtract(start).normalize();
+        let offset = direction.clone().multiplyScalar(distance * 0.5);
+        offset = start.add(offset)
+        //垂直方向的位置
+        const perpendicular = new Vec3(-direction.y, direction.x, 0);
+        offset = offset.add(perpendicular.multiplyScalar(distance * (param?.offset_ratio ?? 0.5) * fx))
+        offset = v3(offset.x, offset.y);
+
+        this.RunTween(item, offset, target_postion, param?.time ?? 1, update)
+    }
+
+    RunTween(target: Node, peakPoint, endPoint, duration, update) {
+        let points = [target.worldPosition.clone(), peakPoint, endPoint];
+        const data = { ratio: 0 }
+        tween(data).to(duration, { ratio: 1 },    // 这里以node的位置信息坐标缓动的目标 
+            {
+                // ITweenOption 的接口实现：
+                onUpdate: (target_data: { ratio: 0 }, ratio: number) => {
+                    const pos = this.GetPosition(target_data.ratio, points)
+                    const pos1 = this.GetPosition(Math.max(ratio * 1.1, 0.001), points)
+                    target.setWorldPosition(pos.x, pos.y, pos.z);
+                    this.LookAt(target, pos1)
+                    update && update(ratio, pos)
+                }
+            }).start();
+    }
+
+    GetPosition(ratio, points) {
+        const t = ratio
+        // 二次贝塞尔曲线公式
+        let x = (1 - t) * (1 - t) * points[0].x + 2 * (1 - t) * t * points[1].x + t * t * points[2].x;
+        let y = (1 - t) * (1 - t) * points[0].y + 2 * (1 - t) * t * points[1].y + t * t * points[2].y;
+        const pos = v3(x, y);
+        return pos
+    }
+
+    LookAt(target: Node, endPoint: Vec3) {
+        const direction = endPoint.clone().subtract(target.worldPosition).normalize(); // 计算A点指向B点的方向向量
+        const angle = Math.atan2(direction.x, direction.y); // 计算夹角（弧度）
+        let euler = v3(0, 0, -misc.radiansToDegrees(angle)); // 应用欧拉角到A点
+        target.eulerAngles = euler
+        return angle;
+    }
+
+    getEuler(start: Vec3, end: Vec3) {
+        const direction = end.clone().subtract(start).normalize(); // 计算A点指向B点的方向向量
+        const angle = Math.atan2(direction.x, direction.y); // 计算夹角（弧度）
+        let euler = v3(0, 0, -misc.radiansToDegrees(angle)); // 应用欧拉角到A点
+        return -misc.radiansToDegrees(angle);
+    }
+
+    /**
+     * 生成抛物线上的指定数量坐标点
+     * @param start 起始点
+     * @param peak 控制点（峰值点）
+     * @param end 结束点
+     * @param count 点的数量
+     * @returns 坐标点数组
+     */
+    generateParabolaPoints(param: { start: Vec3, end: Vec3, offset_ratio: number, count: number }) {
+        //中心点
+        const distance = Vec3.distance(param.start, param.end)
+        const direction = param.end.clone().subtract(param.start).normalize();
+        let center = direction.clone().multiplyScalar(distance * 0.5);
+        center = param.start.clone().add(center)
+        //中心点垂直方向的位置
+        const perpendicular = new Vec3(-direction.y, direction.x, 0);
+        center = center.add(perpendicular.multiplyScalar(distance * (param?.offset_ratio ?? 0.5)))
+        const points = [param.start, center, param.end];
+        const result: { positions: Vec3, rotion: number }[] = []
+        for (let i = 0; i < param.count; i++) {
+            const ratio = i / (param.count - 1);
+            const pos = this.GetPosition(ratio, points);
+            const pos1 = this.GetPosition(Math.max(ratio * 1.1, 0.001), points)
+            const euler = this.getEuler(pos, pos1)
+            result.push({ positions: pos, rotion: euler });
+        }
+        return result;
+    }
+}
+
+

package/assets/core/home/ParabolaTween.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "3fd4c65e-d51d-46a4-a8d5-e77008afbca2",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/core/home/ProgessView.ts

@@ -0,0 +1,96 @@
+
+import { tween } from 'cc';
+import { ProgressBar } from 'cc';
+import { _decorator, Component, Node, game, find, director } from 'cc';
+const { ccclass, property, menu } = _decorator;
+
+/**
+ * Predefined variables
+ * Name = ProgessView
+ * DateTime = Wed Sep 28 2022 22:24:36 GMT+0800 (中国标准时间)
+ * Author = yf123mb
+ * FileBasename = ProgessView.ts
+ * FileBasenameNoExtension = ProgessView
+ * URL = db://assets/home/Home/ProgessView.ts
+ * ManualUrl = https://docs.cocos.com/creator/3.4/manual/zh/
+ *
+ */
+
+@ccclass('ProgessView')
+@menu('组件进度条/ProgessView')
+export class ProgessView extends Component {
+
+    // static Ins:ProgessView;
+    @property({
+        type: ProgressBar,
+        displayName: "进度条"
+    })
+    pro_bar!: ProgressBar;
+
+    protected onLoad(): void {
+
+    }
+
+    SHowPro(isShow: boolean) {
+        this.pro_bar.node.active = isShow
+    }
+
+    stop = false
+    async SetProgessAuto(isOk) {
+        this.stop = isOk
+        if (isOk) {
+            for (var i = 90; i < 101; i++) {
+                await MainModule.timeManager.AwaitMS(1);
+                this.SetProgessValue((i));
+            }
+            this.Hide()
+        } else {
+            for (var i = 0; i < 90; i++) {
+                if (this.stop) { return }
+                await MainModule.timeManager.AwaitMS(1);
+                this.SetProgessValue((i));
+            }
+        }
+    }
+
+    async SetProgessValue(value: number) {
+        if (this.pro_bar) {
+            this.pro_bar.SetValue(value);
+            //    console.log(value);
+            if (value >= 100) {
+                //  this.Hide();
+            }
+        }
+
+    }
+
+    Show() {
+        this.node.active = true;
+    }
+
+    Hide() {
+        this.node.active = false;
+    }
+
+
+    pro(this: ProgressBar, progress: number, max: number, anim_time?: number): void {
+
+        const com_max_pro = this.totalLength//getComponent(UITransform).width
+        const max_progress = com_max_pro;
+        const s = max_progress / max;
+        const pro = progress * s / max_progress;
+
+        if (anim_time) {
+            tween(this).to(anim_time, {
+                progress: pro
+            }).start();
+
+        } else {
+            this.progress = pro;
+
+        }
+    }
+
+
+}
+

package/assets/core/home/ProgessView.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "96d1908c-58b4-4a85-b31a-f7dd458c0ace",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/core/home/Quaternion.ts

@@ -0,0 +1,237 @@
+import { EPSILON, Mat3, math, quat, Quat } from "cc";
+
+/**
+ * 该类属于一个引擎内部的Quat四元数类的一个扩展简化版
+ * 因为本人觉得有些out参数过于多余，在这里就隐藏掉了
+ * 同时也加了些其他的四元数旋转的功能
+ */
+export class Quaternion {
+
+    private static Deg2Rad: number = (Math.PI) / 180;
+
+    /**
+     * 绕Y轴旋转置顶节点
+     * @param _node 需要旋转的节点
+     * @param _angle 旋转的角度（是角度不是弧度）
+     */
+    public static RotateY(_node: Node, _angle: number): Quat {
+        let _quat = new Quat();
+        _node.rotation = Quat.rotateY(_quat, _node.rotation, _angle * this.Deg2Rad);
+        return _quat;
+    }
+
+    /**
+    * 绕X轴旋转置顶节点
+    * @param _node 需要旋转的节点
+    * @param _angle 旋转的角度（是角度不是弧度）
+    */
+    public static RotateX(_node: Node, _angle: number): Quat {
+        let _quat = new Quat();
+        _node.rotation = Quat.rotateX(_quat, _node.rotation, _angle * this.Deg2Rad);
+        return _quat;
+    }
+
+    /**
+    * 绕Z轴旋转置顶节点
+    * @param _node 需要旋转的节点
+    * @param _angle 旋转的角度（是角度不是弧度）
+    */
+    public static RotateZ(_node: Node, _angle: number): Quat {
+        let _quat = new Quat();
+        _node.rotation = Quat.rotateZ(_quat, _node.rotation, _angle * this.Deg2Rad);
+        return _quat;
+    }
+
+    /**
+     * 绕世界空间下指定轴旋转四元数
+     * @param _targetQuat 指定要旋转四元数
+     * @param axis 旋转轴
+     * @param _angle 旋转角度
+     */
+    public static RotateAround(_targetQuat: Quat, axis: Vec3, _angle: number): Quat {
+        let _quat = new Quat();
+        Quat.rotateAround(_quat, _targetQuat, axis, _angle * this.Deg2Rad);
+        return _quat;
+    }
+
+    /**
+     *  绕本地空间下指定轴旋转四元数
+     * @param _targetQuat 指定要旋转四元数
+     * @param axis 旋转轴
+     * @param _angle 旋转角度
+     */
+    public static RotateAroundLocal(_targetQuat: Quat, axis: Vec3, _angle: number): Quat {
+        let _quat = new Quat();
+        Quat.rotateAroundLocal(_quat, _targetQuat, axis, _angle * this.Deg2Rad);
+        return _quat;
+    }
+
+    /**
+     * 将变换围绕穿过世界坐标中的 point 的 axis 旋转 angle 度。
+     * 这会修改变换的位置和旋转。
+     * @param self 要变换旋转的目标
+     * @param pos 指定围绕的point
+     * @param axis 旋转轴
+     * @param angle 旋转角度
+     */
+    public static RotationAroundNode(self: Node, pos: Vec3, axis: Vec3, angle: number): Quat {
+        let _quat = new Quat();
+        let v1 = new Vec3();
+        let v2 = new Vec3();
+        let pos2: Vec3 = self.position;
+        let rad = angle * this.Deg2Rad;
+        Quat.fromAxisAngle(_quat, axis, rad);
+        Vec3.subtract(v1, pos2, pos);
+        Vec3.transformQuat(v2, v1, _quat);
+        self.position = Vec3.add(v2, pos, v2);
+        Quat.rotateAround(_quat, self.rotation, axis, rad);
+        return _quat;
+    }
+
+    /**
+     * 从四元数得到欧拉角
+     * @param _quat 四元数
+     */
+    public static GetEulerFromQuat(_quat: Quat): IVec3Like {
+        let angle: IVec3Like = Quat.toEuler(new Vec3(), _quat, true);
+        return angle;
+    }
+
+    /**
+     * 从欧拉角得到四元数
+     * @param _angle 欧拉角
+     */
+    public static GetQuatFromAngle(_angle: IVec3Like): Quat {
+        let _quat: Quat = Quat.fromEuler(new Quat(), _angle.x, _angle.y, _angle.z);
+        return _quat;
+    }
+
+    /**
+     * 四元数差值，在 a 和 b 之间插入 t，然后对结果进行标准化处理。参数 t 被限制在 [0, 1] 范围内。
+     * 该方法比 Slerp 快，但如果旋转相距很远，其视觉效果也更糟糕。
+     * @param _a 
+     * @param _b 
+     * @param _t 
+     */
+    public static Lerp(_a: Quat, _b: Quat, _t: number): Quat {
+        let _quat = new Quat();
+        Quat.lerp(_quat, _a, _b, _t);
+        return _quat;
+    }
+
+    /**
+     * 四元数球形差值
+     * 在 a 和 b 之间以球形方式插入 t。参数 t 被限制在 [0, 1] 范围内。
+     * @param _a 
+     * @param _b 
+     * @param _t 
+     */
+    public static Slerp(_a: Quat, _b: Quat, _t: number): Quat {
+        let _quat = new Quat();
+        Quat.slerp(_quat, _a, _b, _t);
+        return _quat;
+    }
+
+
+    public static LookRotation(_forward: Vec3, _upwards: Vec3 = Vec3.UP): Quat {
+        let _quat = new Quat();
+        Vec3.normalize(_forward, _forward);
+        Quat.fromViewUp(_quat, _forward, _upwards);
+        return _quat;
+    }
+
+}
+
+
+import { _decorator, Node, Vec3, IVec3Like } from 'cc';
+
+
+export class VectorTool {
+
+    public static SmoothDampV3(current: IVec3Like, target: Vec3, currentVelocity: IVec3Like, smoothTime: number, maxSpeed: number, deltaTime: number) {
+        let outputX: number = 0;
+        let outputY: number = 0;
+        let outputZ: number = 0;
+        smoothTime = Math.max(0.0001, smoothTime);
+        let omega: number = 2 / smoothTime;
+        let x: number = omega * deltaTime;
+        let exp: number = 1 / (1 + x + 0.48 * x * x + 0.235 * x * x * x);
+        let changX: number = current.x - target.x;
+        let changY: number = current.y - target.y;
+        let changZ: number = current.z - target.z;
+        let originalTo: Vec3 = target;
+
+        let maxChange: number = maxSpeed * smoothTime;
+
+        let maxChangeSq: number = maxChange * maxChange;
+        let sqrmag: number = changX * changX + changY * changY + changZ * changZ;
+        if (sqrmag > maxChangeSq) {
+            let mag: number = Math.sqrt(sqrmag);
+            changX = changX / mag * maxChangeSq;
+            changY = changY / mag * maxChangeSq;
+            changZ = changZ / mag * maxChangeSq;
+        }
+
+        target.x = current.x - changX;
+        target.y = current.y - changY;
+        target.z = current.z - changZ;
+
+        let tempX: number = (currentVelocity.x + omega * changX) * deltaTime;
+        let tempY: number = (currentVelocity.y + omega * changY) * deltaTime;
+        let tempZ: number = (currentVelocity.z + omega * changZ) * deltaTime;
+
+        currentVelocity.x = (currentVelocity.x - omega * tempX) * exp;
+        currentVelocity.y = (currentVelocity.y - omega * tempY) * exp;
+        currentVelocity.z = (currentVelocity.z - omega * tempZ) * exp;
+
+        outputX = target.x + (changX + tempX) * exp;
+        outputY = target.y + (changY + tempY) * exp;
+        outputZ = target.z + (changZ + tempZ) * exp;
+
+        let origMinusCurrentX: number = originalTo.x - current.x;
+        let origMinusCurrentY: number = originalTo.y - current.y;
+        let origMinusCurrentZ: number = originalTo.z - current.z;
+        let outMinusOrigX: number = outputX - originalTo.x;
+        let outMinusOrigY: number = outputY - originalTo.y;
+        let outMinusOrigZ: number = outputZ - originalTo.z;
+
+        if (origMinusCurrentX * outMinusOrigX + origMinusCurrentY * outMinusOrigY + origMinusCurrentZ * outMinusOrigZ > 0) {
+            outputX = originalTo.x;
+            outputY = originalTo.y;
+            outputZ = originalTo.z;
+
+            currentVelocity.x = (outputX - originalTo.x) / deltaTime;
+            currentVelocity.y = (outputY - originalTo.y) / deltaTime;
+            currentVelocity.z = (outputZ - originalTo.z) / deltaTime;
+        }
+        return new Vec3(outputX, outputY, outputZ);
+
+    }
+
+    public static SmoothDamp(current: number, target: number, currentVelocity: number, smoothTime: number, maxSpeed: number, deltaTime: number) {
+        smoothTime = Math.max(0.0001, smoothTime);
+        let num: number = 2 / smoothTime;
+        let num2: number = num * deltaTime;
+        let num3: number = 1 / (1 + num2 + 0.48 * num2 * num2 + 0.235 * num2 * num2 * num2);
+        let num4: number = current - target;
+        let num5: number = target;
+        let num6: number = maxSpeed * smoothTime;
+        num4 = VectorTool.Clamp(num4, -num6, num6);
+        target = current - num4;
+        let num7: number = (currentVelocity + num * num4) * deltaTime;
+        currentVelocity = (currentVelocity - num * num7) * num3;
+        let num8: number = target + (num4 + num7) * num3;
+        if (num5 - current > 0 == num8 > num5) {
+            num8 = num5;
+            currentVelocity = (num8 - num5) / deltaTime;
+        }
+        return num8;
+    }
+
+    public static Clamp(val: number, min: number, max: number) {
+        if (val <= min) val = min;
+        if (val >= max) val = max;
+
+        return val;
+    }
+}