_Aliens/assets/module_aliens/Script/LevelAction.ts

import { _decorator, BoxCollider2D, Button, Camera, CCFloat, CircleCollider2D, Color, Component, debug, DebugView, director, EventTouch, find, geometry, Input, input, math, Node, NodeEventType, PhysicsSystem, Quat, RenderTexture, Tween, tween, v3, Vec3, view } from 'cc';
import { EventDispatcher } from '../../core_tgx/easy_ui_framework/EventDispatcher';
import { GameEvent } from './Enum/GameEvent';
import { LineDrawer } from './LineDrawer';
import { EnemyComponent } from './Components/EnemyComponent';
import { AliensGlobalInstance } from './AliensGlobalInstance';
import { ScreenShotComponent } from './Components/ScreenShotComponent';
import { GameUtil } from './GameUtil';
import { RadarComponent } from './Components/RadarComponent';

const { ccclass, property } = _decorator;

enum ERaycastType {
    ALL,
    CLOSEST
}
@ccclass('LevelAction')
export class LevelAction extends Component {

    @property(Camera)
    public camera: Camera = null!;

    private _renderTex: RenderTexture | null = null;
    private _cameraOriginalPos: Vec3 = v3();
    private _touchStartPos: Vec3 = v3();
    private _isDragging = false;
    private _isZooming = false;
    public targetNode: Node = null!;

    // 添加旋转限制属性
    @property({type: CCFloat ,displayName:"相机X轴最小旋转角度(上下)"})
    public minXRotation: number = -30;  // X轴最小旋转角度(上下)
    @property({type: CCFloat ,displayName:"相机X轴最大旋转角度(上下)"}) 
    public maxXRotation: number = 30;   // X轴最大旋转角度(上下)
    @property({type: CCFloat ,displayName:"相机Y轴最小旋转角度(左右)"})
    public minYRotation: number = -50;  // Y轴最小旋转角度(左右)
    @property({type: CCFloat ,displayName:"相机Y轴最大旋转角度(左右)"})
    public maxYRotation: number = 50;   // Y轴最大旋转角度(左右)
    private _originalRotation: Vec3 = v3();

    //镜头拉近属性
    private _zoomDuration: number = 0.5; // 拉近持续时间(秒)

    private _raycastType: ERaycastType = ERaycastType.ALL;

    onLoad(): void {
        this._cameraOriginalPos = this.camera.node.position.clone();
        this._originalRotation = this.camera.node.eulerAngles.clone();
        this.registerEvent();
    }

    start() {
        this.initilizeUI();
        this.saveCameraState();
    }

    private initilizeUI(){
        const renderNode = AliensGlobalInstance.instance.renderNode;
        const aimTarget = AliensGlobalInstance.instance.aimTarget;
        const radarNode = AliensGlobalInstance.instance.radarNode;
        renderNode.active = false;
        aimTarget.active = false;
        radarNode.active = false;
    }

    private registerEvent(){
        // 触摸事件监听
        input.on(Input.EventType.TOUCH_START, this._onTouchStart, this);
        input.on(Input.EventType.TOUCH_MOVE, this._onTouchMove, this);
        input.on(Input.EventType.TOUCH_END, this._onTouchEnd, this);
        input.on(Input.EventType.TOUCH_CANCEL, this._onTouchEnd, this);

        //事件监听
        EventDispatcher.instance.on(GameEvent.EVENT_CAMERA_AIM,this.onAimTarget,this);
        EventDispatcher.instance.on(GameEvent.EVENT_CAMERA_RESET_AIM,this.onResetAimTarget,this);
        EventDispatcher.instance.on(GameEvent.EVENT_CAMERA_SHOOT,this.onShoot,this);
        EventDispatcher.instance.on(GameEvent.EVENT_CAMERA_SCREENSHOT_RADAR_LOCK,this.onCameraToTarget,this);
    }

    private unRegisterEvent(){
        // 触摸事件监听
        input.off(Input.EventType.TOUCH_START, this._onTouchStart, this);
        input.off(Input.EventType.TOUCH_MOVE, this._onTouchMove, this); 
        input.off(Input.EventType.TOUCH_END, this._onTouchEnd, this);
        input.off(Input.EventType.TOUCH_CANCEL, this._onTouchEnd, this);

        //事件监听
        EventDispatcher.instance.off(GameEvent.EVENT_CAMERA_AIM,this.onAimTarget,this);
        EventDispatcher.instance.off(GameEvent.EVENT_CAMERA_RESET_AIM,this.onResetAimTarget,this);
        EventDispatcher.instance.off(GameEvent.EVENT_CAMERA_SHOOT,this.onShoot,this);
        EventDispatcher.instance.off(GameEvent.EVENT_CAMERA_SCREENSHOT_RADAR_LOCK,this.onCameraToTarget,this);
    }

    private onAimTarget(){
        this.moveCameraAlongForward(-30); // 负值表示拉近
    }

    private onResetAimTarget(){
        this.moveCameraAlongForward(30); // 正值表示拉远
    }

    private onShoot(){
       // 获取正确的屏幕中心坐标
       const screenCenter = view.getVisibleSize();
       const screenX = screenCenter.width * 0.5 * view.getScaleX();
       const screenY = screenCenter.height * 0.5 * view.getScaleY();

       // 从屏幕中心发射射线
       const ray = new geometry.Ray();
       this.camera.screenPointToRay(screenX, screenY, ray);
        
        // 射线检测参数
        const mask = 0xffffffff;
        const maxDistance = 1000;
        const queryTrigger = true;
        
        // 执行射线检测
        const hasHit = PhysicsSystem.instance.raycast(ray, mask, maxDistance, queryTrigger);
        
        if (hasHit) {
            const results = PhysicsSystem.instance.raycastResults;
            for (let i = 0; i < results.length; i++) {
                const item = results[i];
                const hitNode = item.collider.node;
                // console.log(`碰撞物体${i}: ${hitNode.name} 距离: ${item.distance.toFixed(2)}`);

                if(hitNode.getComponent(EnemyComponent)){
                    EventDispatcher.instance.emit(GameEvent.EVENT_CAMERA_SHOOT_TEXT);
                    EventDispatcher.instance.emit(GameEvent.EVENT_CAMERA_SHOOT_ENEMY,hitNode);
                }
            }
        }
    }
    
    private moveCameraAlongForward(distance: number) {
        if(this._isZooming) return;

        this._isZooming = true;
        const currentPos = this.camera.node.position.clone();
        const forward = this.camera.node.forward.negative();
        const targetPos = currentPos.add(forward.multiplyScalar(distance));
        
        tween(this.camera.node.position)
            .to(this._zoomDuration, targetPos, {
                easing: 'smooth',
                onUpdate: (target: Vec3) => {
                    this.camera.node.position = target;
                    // 根据镜头距离动态调整旋转限制
                    this.adjustRotationLimits();
                    this._isZooming = false; 
                }
            })
            .start();
    }

    //相机转向目标
    private async onCameraToTarget(targetNode: Node){
        const camera = this.camera;
        if (!targetNode || !camera) return;

        const targetWorldPos = targetNode.worldPosition.clone();
        const screenPos = camera.worldToScreen(targetWorldPos, new Vec3());

        const screenSize = view.getVisibleSize();
        const isInView = screenPos.z > 0 &&
                         screenPos.x >= 0 && screenPos.x <= screenSize.x &&
                         screenPos.y >= 0 && screenPos.y <= screenSize.y;

        if (isInView) {
            this.preciselyLookAt(targetNode);
        } else {
            // this.coarselyTurnToTarget(targetNode);
        }
        await this.saveCameraState();
    }

    //粗略旋转，控制相机大致朝向目标
    private coarselyTurnToTarget(targetNode: Node) {
        const camera = this.camera.node;
        const targetPos = targetNode.worldPosition.clone();
        
        // 计算目标方向向量
        const direction = new Vec3();
        Vec3.subtract(direction, targetPos, camera.worldPosition);
        direction.normalize();
        
        // 计算粗略旋转角度
        const roughRotation = new Vec3();
        roughRotation.y = Math.atan2(direction.x, direction.z) * 180 / Math.PI;
        roughRotation.x = -Math.asin(direction.y) * 180 / Math.PI;
        roughRotation.z = 0; // 保持Z轴不变
        
        // 使用缓动动画旋转相机
        tween(camera.eulerAngles)
            .to(0.3, roughRotation, {
                easing: 'sineOut',
                onUpdate: (target: Vec3) => {
                    camera.setRotationFromEuler(target);
                }
            })
            .start();
    }
    
    //精准对准
    private preciselyLookAt(targetNode: Node) {
        const camera = this.camera.node;
        const targetPos = targetNode.worldPosition.clone();
        
        // 保存初始旋转状态
        const initialRotation = this._originalRotation.clone();
        
        // 计算目标相对于相机的方向
        const direction = new Vec3();
        Vec3.subtract(direction, targetPos, camera.worldPosition);
        direction.normalize();
        
        // 基于初始旋转状态计算新角度
        const newRotation = new Vec3();
        newRotation.y = initialRotation.y - direction.x * 10; // 调整系数
        newRotation.x = initialRotation.x + direction.y * 10;
        
        // 应用旋转限制
        newRotation.x = Math.max(this.minXRotation, Math.min(this.maxXRotation, newRotation.x));
        newRotation.y = Math.max(this.minYRotation, Math.min(this.maxYRotation, newRotation.y));
        
        // 设置相机旋转
        camera.setRotationFromEuler(newRotation);
    }

    private adjustRotationLimits() {
        // 计算当前镜头距离比例 (0-1范围)
        const distanceRatio = Math.min(1, Math.max(0, (this.camera.node.position.z - this._cameraOriginalPos.z) / -30));
        
        // 动态调整旋转限制范围
        const dynamicMinY = this.minYRotation * (1 + distanceRatio);
        const dynamicMaxY = this.maxYRotation * (1 + distanceRatio);
        
        // 应用调整后的限制
        this.minYRotation = dynamicMinY;
        this.maxYRotation = dynamicMaxY;
    }

    /***************************触摸事件**********************************/
    private _onTouchStart(event: EventTouch) {
        const touchPos = event.getLocation();
        this._touchStartPos = v3(touchPos.x, touchPos.y, 0);
        this._isDragging = true;
        // 记录初始旋转角度
        this._originalRotation = this.camera.node.eulerAngles.clone();

        const radarComponent = AliensGlobalInstance.instance.renderNode.getComponent(RadarComponent)!;
        if(radarComponent){
            radarComponent.unlockPositionUpdate();
        }
    }
    
    private async _onTouchMove(event: EventTouch) {
        if (!this._isDragging) return;
        
        const currentPos = event.getLocation();
        const deltaX = currentPos.x - this._touchStartPos.x;
        const deltaY = currentPos.y - this._touchStartPos.y;
        
        // 仅计算旋转角度变化
        const newRotation = this._originalRotation.clone();
        newRotation.y = this._originalRotation.y - deltaX * 0.2;
        newRotation.x = this._originalRotation.x + deltaY * 0.2;
        
        // 添加旋转限制
        newRotation.x = Math.max(this.minXRotation, Math.min(this.maxXRotation, newRotation.x));
        newRotation.y = Math.max(this.minYRotation, Math.min(this.maxYRotation, newRotation.y));
        
        this.camera.node.setRotationFromEuler(newRotation);
        await this.saveCameraState();
    }

    //保存相机的位置和旋转角度
    private async saveCameraState() {
        const cameraOriginalPos = this.camera.node.worldPosition.clone();
        const originalRotation = this.camera.node.eulerAngles.clone(); 
        const screenShot = AliensGlobalInstance.instance.renderNode.getComponent(ScreenShotComponent)!;
        screenShot.saveCameraState(cameraOriginalPos,originalRotation);
    }

    private _onTouchEnd() {
        this._isDragging = false;

        const radarComponent = AliensGlobalInstance.instance.renderNode.getComponent(RadarComponent)!;
        if(radarComponent){
            radarComponent.unlockPositionUpdate();
        }
    }

 /***************************触摸事件end**********************************/

    onDestroy () {
        Tween.stopAllByTarget(this.node);
        this.unRegisterEvent();
        if (this._renderTex) {
            this._renderTex.destroy();
            this._renderTex = null;
        }
    }
}