@cc-component/cc-core 1.2.8

package/assets/core/home/CameraAngel.ts

@@ -0,0 +1,326 @@
+import { _decorator, Component, Event, Node, Button, Animation, EventHandler, Color, EventTouch, tween, Vec3, Quat, CCBoolean, v3, misc, mat4, math, Mat4, find, EventKeyboard, macro, director, UITransform } from 'cc';
+import { FollowCamera } from './FollowCamera';
+const { ccclass, property } = _decorator;
+
+@ccclass('CameraAngel')
+export class CameraAngel extends Component {
+
+    targetCube: Node = null;
+
+    @property
+    rotationSpeed: number = 1;
+    private isTouching: boolean = false;
+
+    private touchStartPos: Vec3 = new Vec3();
+
+    followCamera: FollowCamera;
+
+
+    distance = 50;
+
+    touNode:Node;
+    touNodeSize:UITransform;
+    start() {
+
+        // this.node.on(Node.EventType.MOUSE_DOWN, this.MouseDown, this);
+
+        let node = find("Home/root/yaogan")
+        this.touNode = find("Home/root/yaogan/tou")
+        this.touNodeSize = this.touNode.getComponent(UITransform)
+
+        node.on(Node.EventType.TOUCH_START, this.TouchStart, this);
+        node.on(Node.EventType.TOUCH_MOVE, this.TouchMove, this);
+        node.on(Node.EventType.TOUCH_END, this.TouchEnd, this);
+        node.on(Node.EventType.TOUCH_CANCEL, this.TouchEnd, this);
+
+        //this.UpdatePos(0, 0)
+
+        // systemEvent.on(SystemEvent.EventType.KEY_DOWN, this.onKeyDown, this);
+        // systemEvent.on(SystemEvent.EventType.KEY_UP, this.onKeyUp, this);
+
+
+
+    }
+
+    StartGame(targetCube:Node) {
+        this.targetCube = targetCube;
+        this.followCamera = this.getComponent(FollowCamera)
+        this.followCamera.StartGame(this.targetCube,this.distance)
+    }
+
+    
+    private MouseDown(e: Event) {
+
+        console.log("222");
+    }
+
+
+    protected update(dt: number): void {
+        if (this.targetCube) {
+            let fff = Vec3.FORWARD
+            fff = v3(0, 0, -1).multiplyScalar(0.01)
+            //  console.log(fff);
+            //   this.targetCube.worldPosition = this.targetCube.worldPosition.add(fff)
+            // this.UpdatePos(0, 0)
+            // this.SetPos();
+        }
+    }
+
+
+
+    fromRotation(axis, angle) {
+        let euler = new Vec3();
+        euler.set(axis.x * misc.radiansToDegrees(angle), axis.y * misc.radiansToDegrees(angle), axis.z * misc.radiansToDegrees(angle));
+
+        let quat = new Quat();
+        Quat.fromEuler(quat, euler.x, euler.y, euler.z);
+
+        return quat;
+    }
+
+
+
+    private TouchStart(e: EventTouch) {
+        this.isTouching = true;
+        this.touchStartPos = this.GetPos(e);
+      //å  console.log("开始", this.touchStartPos)
+
+        this.isHave = false
+        this.f_x = v3(0)
+
+    }
+
+    GetPos(e:EventTouch){
+
+        let super_pos = this.touNode.parent.worldPosition
+        let pos = v3(super_pos.x ,super_pos.y,0)//this.touNode.parent.position;
+        return v3(e.getUILocation().x-pos.x, e.getUILocation().y-pos.y,0)
+
+
+    }
+
+
+
+    f_x: Vec3 = v3(0)
+    isHave = false
+    private TouchMove(e: EventTouch) {
+        if (!this.isTouching) {
+            return;
+        }
+
+
+        let pos = this.GetPos(e);;
+        this.UpdatePos(pos.x, pos.y);
+    
+
+    }
+
+    private TouchEnd(e: EventTouch) {
+
+        this.ResetPos();
+        if( this.touNode){
+            this.touNode.position = v3(75,75)
+
+        }
+
+ 
+    }
+
+
+    ResetPos(){
+        this.followCamera.isMove = false;
+        this.followCamera.resetPos();
+    }
+
+
+    UpdatePos(x, y) {
+    
+        if (this.followCamera.isUpdatePos) {
+            return
+        }
+
+     
+        if(this.touNode){
+            this.touNode.position = v3(x,y)
+            
+
+        }
+       // console.log(x,y)
+       // console.log("ddd");
+        this.followCamera.isMove = true;
+        let currentPos = new Vec3(x, y, 0);
+        let delta = currentPos.clone().subtract(this.touchStartPos);
+
+        if (delta.x < this.f_x.x && !this.f_x.equals(v3(0), 0.01)) {
+            this.touchStartPos = this.f_x
+            //  console.log("转");
+        }
+
+        //console.log(currentPos)
+        this.f_x = currentPos.clone();
+        // 根据 deltaX 进行旋转
+       // console.log(delta);
+        this.rotateByDeltaX(delta.x,delta.y);
+        //this.rotateAndLookAtTarget()
+
+        this.touchStartPos.clone().set(currentPos);
+    }
+
+    // private rotateByDeltaX(deltaX: number) {
+    //     if (!this.targetCube) {
+
+    //         return
+    //     }
+    //     // 根据 deltaX 计算旋转角度
+    //     let rotationAngle = -deltaX * 0.0001; // 调整旋转速度
+
+    //     // 创建绕 Y 轴旋转的四元数
+    //     let rotationQuat = this.fromRotation(v3(0, 1, 0), misc.radiansToDegrees(rotationAngle));
+
+    //     // 使用四元数进行旋转
+    //     let rotatedPos = new Vec3();
+    //     math.Vec3.transformQuat(rotatedPos, this.node.position.clone().subtract(this.targetCube.worldPosition), rotationQuat);
+
+    //     // 更新摄像机位置
+    //     this.node.setWorldPosition(rotatedPos.add(this.targetCube.worldPosition));
+
+    //     // 摄像机始终朝向目标立方体
+    //     this.node.lookAt(this.targetCube.worldPosition);
+    // }
+
+
+    // private rotateByDeltaX(deltaX: number) {
+    //     if (!this.targetCube) {
+    //         return;
+    //     }
+
+
+    //     // 根据deltaX计算旋转角度
+    //     let rotationAngle = -deltaX * 0.0001;
+
+    //     // 创建围绕Y轴旋转的四元数
+    //     let rotationQuat = this.fromRotation(v3(0, 1, 0), misc.radiansToDegrees(rotationAngle));
+
+    //     // 计算从相机到targetCube的向量
+
+    //     let cameraToTarget = this.node.position.clone().subtract(this.targetCube.worldPosition);
+
+    //     // 将四元数旋转应用于向量
+    //     math.Vec3.transformQuat(cameraToTarget, cameraToTarget, rotationQuat);
+
+    //     // 确保距离targetCube的固定距离为10个单位
+    //     let distance = 30;
+    //     let rotatedPos = this.targetCube.worldPosition.clone().add(cameraToTarget.normalize().multiplyScalar(distance));
+
+    //     // 更新相机位置
+    //     this.node.setWorldPosition(rotatedPos);
+
+    //     // 保持相机始终朝向targetCube
+    //     this.node.lookAt(this.targetCube.worldPosition);
+    // }
+
+    private rotateByDeltaX(deltaX: number, deltaY: number) {
+        if (!this.targetCube) {
+            return;
+        }
+
+        // 根据deltaX和deltaY计算旋转角度
+        let rotationAngleX = -deltaY * 0.0001; // deltaY用于X轴旋转
+        let rotationAngleY = -deltaX * 0.0001; // deltaX用于Y轴旋转
+
+        // 创建围绕X轴和Y轴旋转的两个四元数
+        let rotationQuatX = this.fromRotation(v3(1, 1, 0), misc.radiansToDegrees(rotationAngleX));
+        let rotationQuatY = this.fromRotation(v3(0, 1, 0), misc.radiansToDegrees(rotationAngleY));
+      //  let rotationQuatz = this.fromRotation(v3(0, 0, 1), misc.radiansToDegrees(rotationAngleY));
+
+        let combinedQuat = rotationQuatY//this.multiplyQuaternions(rotationQuatX, rotationQuatY)
+        // 将两个四元数相乘，以获得综合的旋转效果
+       // let combinedQuat = math.Quat.multiply(rotationQuatX, rotationQuatY, rotationQuatX);
+
+        // 计算从相机到targetCube的向量
+        let cameraToTarget = this.node.worldPosition.clone().subtract(this.targetCube.worldPosition);
+
+        // 将综合的四元数旋转应用于向量
+        math.Vec3.transformQuat(cameraToTarget, cameraToTarget, combinedQuat);
+
+        // 确保距离targetCube的固定距离为10个单位
+        let distance = this.distance;
+        let rotatedPos = this.targetCube.worldPosition.clone().add(cameraToTarget.normalize().multiplyScalar(distance));
+
+        // 更新相机位置
+        this.node.setWorldPosition(v3(rotatedPos));
+
+        // 保持相机始终朝向targetCube
+        this.node.lookAt(this.targetCube.worldPosition);
+    }
+
+     multiplyQuaternions(quat1: math.Quat, quat2: math.Quat): math.Quat {
+    let result = new math.Quat();
+
+    // Quaternion multiplication formula: result = quat2 * quat1
+    result.x = quat2.x * quat1.w + quat2.y * quat1.z - quat2.z * quat1.y + quat2.w * quat1.x;
+    result.y = -quat2.x * quat1.z + quat2.y * quat1.w + quat2.z * quat1.x + quat2.w * quat1.y;
+    result.z = quat2.x * quat1.y - quat2.y * quat1.x + quat2.z * quat1.w + quat2.w * quat1.z;
+    result.w = -quat2.x * quat1.x - quat2.y * quat1.y - quat2.z * quat1.z + quat2.w * quat1.w;
+
+    return result;
+}
+
+    rotateAndLookAtTarget() {
+        if (!this.targetCube) {
+            return;
+        }
+
+        // 旋转相机位置（45度角）
+        let rotationAngle = misc.degreesToRadians(90); // 将角度转换为弧度
+        //let rotationQuat = Quat.fromAxisAngle(v3(0, 1, 0), rotationAngle);
+        let rotationQuat = this.fromRotation(v3(0, 1, 0), misc.radiansToDegrees(rotationAngle));
+        let rotatedDirection = v3(1, 1, -1); // 初始方向
+        math.Vec3.transformQuat(rotatedDirection, rotatedDirection, rotationQuat);
+
+        // 确保距离targetCube的固定距离为10个单位
+        let distance = 20;
+        let rotatedPos = this.targetCube.worldPosition.clone().add(rotatedDirection.clone().multiplyScalar(distance));
+        let rotatedPos2 = this.targetCube.worldPosition.clone().add(this.node.forward.multiplyScalar(distance * -1));
+
+        console.log(rotatedDirection.clone(), rotatedPos2)
+        // 更新相机位置
+        this.node.setWorldPosition(rotatedPos);
+
+        // 使相机朝向targetCube
+        this.node.lookAt(this.targetCube.worldPosition);
+    }
+
+
+
+    @property
+    speed: number = 300;
+    onKeyDown(event: EventKeyboard) {
+        switch (event.keyCode) {
+            case macro.KEY.w:
+                this.targetCube.worldPosition = this.targetCube.worldPosition.add3f(0, 0, this.speed * director.getDeltaTime());
+                break;
+            case macro.KEY.s:
+                this.targetCube.worldPosition = this.targetCube.worldPosition.subtract3f(0, 0, this.speed * director.getDeltaTime());
+
+                break;
+            case macro.KEY.a:
+                this.targetCube.worldPosition = this.targetCube.worldPosition.subtract3f(this.speed * director.getDeltaTime(), 0, 0);
+
+                break;
+            case macro.KEY.d:
+                this.targetCube.worldPosition = this.targetCube.worldPosition.add3f(this.speed * director.getDeltaTime(), 0, 0);
+                break;
+        }
+     
+
+        this.ResetPos()
+
+       // this.targetCube_lastPos = this.targetCube.worldPosition.clone();
+    }
+
+    onKeyUp(event: EventKeyboard) {
+        // 可以在需要的时候处理键盘抬起事件
+    }
+}
+

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "9c8ac71f-a3fd-4a2f-9c60-dbce3c3bee0b",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/core/home/DouYinShow.ts

@@ -0,0 +1,27 @@
+import { _decorator, CCBoolean, Component, Node } from 'cc';
+import { BYTEDANCE } from 'cc/env';
+const { ccclass, property } = _decorator;
+
+@ccclass('DouYinShow')
+export class DouYinShow extends Component {
+
+    @property({})
+    isTip = false;
+    protected onLoad(): void {
+        if (BYTEDANCE) {
+            if (!MainModule.IsDouYin() && !this.isTip) {
+                this.node.active = false;
+            } else {
+            }
+        }
+
+    }
+    start() {
+
+    }
+
+    update(deltaTime: number) {
+
+    }
+}
+

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "a4a32ee3-6149-4996-ba7b-a710f599ec40",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/core/home/EventManager.ts

@@ -0,0 +1,39 @@
+import { _decorator, EventTarget } from 'cc';
+
+const { ccclass } = _decorator;
+
+@ccclass('EventManager')
+export class EventManager {
+
+    private static instance: EventManager;
+    private eventTarget: EventTarget;
+
+    private constructor() {
+        this.eventTarget = new EventTarget();
+    }
+
+    static get ins() {
+        if (!this.instance) {
+            this.instance = new EventManager();
+        }
+        return this.instance;
+    }
+
+    on(eventName: string, callback: any, target?: any) {
+        this.eventTarget.on(eventName, callback, target);
+    }
+
+    off(eventName: string, callback?: any, target?: any) {
+        this.eventTarget.off(eventName, callback, target);
+    }
+
+    emit(eventName: string, params: any) {
+        this.eventTarget.emit(eventName, params);
+    }
+
+    OffAll(target: any) {
+        this.eventTarget.targetOff(target);
+    }
+}
+
+

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "b7d768ad-679b-4760-a895-453952c0f884",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/core/home/ExView.ts

@@ -0,0 +1,9 @@
+import { BaseBoxView } from "./BaseBoxView";
+
+
+// 扩展 Node 接口，声明自定义属性
+declare module 'cc' {
+    interface Node {
+        BoxView: BaseBoxView;
+    }
+}

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "d7ac4bd9-ab7f-434f-ad91-523ac5c49622",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/core/home/FollowCamera.ts

@@ -0,0 +1,205 @@
+import { Component, EventKeyboard, EventTouch, Node, Quat, Tween, Vec3, _decorator, director, find, macro, math, misc, tween, v3 } from "cc";
+import Message from "./Message";
+import { MessageType } from "./MessageType";
+const { ccclass, property } = _decorator;
+
+const v3_1 = new Vec3;
+
+/**
+ * 自动跟随目标，并平滑移动的摄像机
+ */
+@ccclass
+export class FollowCamera extends Component {
+
+    @property(Node)
+    focusTarget: Node = null as any;
+
+    @property
+    speedFactor: number = 0.05;
+
+    @property
+    private _distance: number = 30.0;
+    @property
+    public get distance(): number {
+        return this._distance;
+    }
+    public set distance(v: number) {
+        this._distance = v;
+        this._updateTargetWorldPos();
+    }
+
+    // Limit range
+    enableLimit: boolean = true;
+    minX = -Infinity;
+    maxX = Infinity;
+    minZ = -Infinity;
+    maxZ = Infinity;
+
+    protected _tweenFollow?: Tween<any>;
+    protected _targetWorldPos = new Vec3;
+    protected _lastTargetPos = new Vec3;
+
+    private static Deg2Rad:number=(Math.PI) / 180;
+
+
+    isMove = false;
+    start() {
+
+       // let node = find("Canvas/yaogan")
+
+        // node.on(Node.EventType.TOUCH_START, this.TouchStart, this);
+        // node.on(Node.EventType.TOUCH_MOVE, this.TouchMove, this);
+        // node.on(Node.EventType.TOUCH_END, this.TouchEnd, this);
+
+
+        
+    }
+
+    StartGame(focusTarget:Node,dis:number){
+
+        
+        this.focusTarget = focusTarget;
+        this._lastTargetPos.set(this.focusTarget.worldPosition.clone());
+        this.distance = dis
+        this._updateTargetWorldPos();
+
+        tween(this.node)
+        .to(0.5, { worldPosition: this._targetWorldPos })
+        .start();
+        
+        //this.node.setWorldPosition(this._targetWorldPos);
+
+       // this.UpdatePos(0, 0)
+    }
+    protected _updateTargetWorldPos() {
+        this._targetWorldPos.set(this.focusTarget.worldPosition.clone());
+        if (this.enableLimit) {
+            this._targetWorldPos.x = FollowCamera.limit(this._targetWorldPos.x, this.minX, this.maxX);
+            this._targetWorldPos.z = FollowCamera.limit(this._targetWorldPos.z, this.minZ, this.maxZ);
+        }
+
+        this._targetWorldPos.add(this.node.forward.multiplyScalar(this.distance * -1));
+       // this._targetWorldPos.add3f(this._targetWorldPos.x,this._targetWorldPos.y,this._targetWorldPos.z);
+    }
+
+    update() {
+        if (!this.focusTarget) {
+            return
+        }
+        if(this.isMove){
+
+           // console.log("阻止")
+            return;
+        }
+
+        this.UpdateP();
+    }
+
+    isUpdatePos = false;
+    UpdateP(){
+        if (!this._lastTargetPos.equals(this.focusTarget.worldPosition.clone())) {
+            this._lastTargetPos.set(this.focusTarget.worldPosition.clone());
+            this._updateTargetWorldPos();
+        }
+
+        // 向TargetWorldPos平滑逼近
+        // Limit Range
+
+        v3_1.set(this._targetWorldPos);
+        let diff = v3_1.subtract(this.node.worldPosition);
+        if (diff.lengthSqr() > 0.01) {
+            let ret = this.node.worldPosition.clone().add(diff.multiplyScalar(this.speedFactor));
+            //ret =  ret.add(v3(0,0.5,0));
+            this.node.setWorldPosition(ret);
+            //console.log('-----',this.node.worldPosition);
+            //this.node.setWorldPosition(v3(ret.x,37,ret.z));
+
+            this.isUpdatePos = true
+        }else{
+            this.isUpdatePos = false
+        }
+    }
+
+
+    IsMovePos(){
+
+        v3_1.set(this._targetWorldPos);
+        let diff = v3_1.subtract(this.node.worldPosition);
+        if (diff.lengthSqr() > 0.01) {
+            this.isUpdatePos = true
+            return true
+        } else {
+            this.isUpdatePos = false
+            return false;
+        }
+
+    }
+
+    /**
+     * 将变换围绕穿过世界坐标中的 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);
+        //把向量dir根据计算到的四元数旋转，然后计算出旋转后的距离
+        Vec3.transformQuat(v2,v1,_quat);
+        self.position=Vec3.add(v2,pos,v2);
+        //根据轴和弧度绕世界空间下指定轴旋转四元数
+        Quat.rotateAround(_quat,self.rotation,axis,rad);
+        return _quat;
+    }
+
+
+    resetPos() {
+        this._updateTargetWorldPos();
+        //this.node.setWorldPosition(this._targetWorldPos);
+
+
+        v3_1.set(this._targetWorldPos);
+        let diff = v3_1.subtract(this.node.worldPosition);
+        if (diff.lengthSqr() > 0.01) {
+            let ret = this.node.worldPosition.clone().add(diff.multiplyScalar(this.speedFactor));
+            //ret =  ret.add(v3(0,0.5,0));
+            this.node.setWorldPosition(ret);
+        }
+    }
+
+    @property
+    get preview() {
+        return false;
+    }
+    set preview(v: boolean) {
+        this.resetPos();
+    }
+
+    @property
+    get autoSetDistance() {
+        return false;
+    }
+    set autuSetDistance(v: boolean) {
+        this.distance = this.node.worldPosition.clone().subtract(this.focusTarget.worldPosition.clone()).length();
+    }
+
+    static limit(src: number, min: number, max: number) {
+        return Math.min(max, Math.max(min, src));
+    }
+
+
+
+
+
+   
+}

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "c9bd92e7-c01c-4515-8c8c-145663b2f03d",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}