pinball/assets/_Game/Scripts/GamePlay/MutilBall.ts

import {
    _decorator,
    AudioClip,
    Collider2D,
    Color,
    Component,
    Contact2DType,
    Node,
    ParticleSystem,
    PolygonCollider2D,
    Prefab,
    Vec2,
} from 'cc';
import TimeConfig from '../Enum/TimeConfig';
import { CameraController } from '../Environments/CameraController';
import GameEvent from '../Events/GameEvent';
import registerGizmos from '../Gizmos/Decorator';
import Gizmos2D from '../Gizmos/Gizmos2D';
import AudioManager from '../Manager/AudioManager';
import { EventManger } from '../Manager/EventManger';
import { GameManager } from '../Manager/GameManager';
import ObjectPool from '../Pool/ObjectPool';
import Utils from '../Utilities';
import { Ball } from './Ball';
const { ccclass, property } = _decorator;

@registerGizmos
@ccclass('MultiBall')
export class MultiBall extends Component {
    @property({ type: Collider2D, visible: true })
    private _collider: Collider2D;
    @property({ type: Node, visible: true })
    private _portLeft;
    @property({ type: Node, visible: true })
    private _portRight;
    @property({ type: Prefab, visible: true })
    private _fx: Prefab;

    @property({ type: AudioClip, visible: true })
    private _soundFX: AudioClip;

    private _originBall: Ball;
    private _trigged = false;
    private _fxPool: ObjectPool;

    private _colliderEnabled: boolean = true;

    onDrawGizmos(): void {
        Gizmos2D.beginColor(this.node, new Color(0, 255, 0, 150));
        const points = (this._collider as PolygonCollider2D).points.map((p) => p.clone().add(this._collider.offset));
        Gizmos2D.beginLocalPosition(this.node);
        Gizmos2D.drawSolidPolygon(this.node, points);
        Gizmos2D.endLocalPosition(this.node);
        Gizmos2D.beginColor(this.node, new Color(0, 0, 255, 150));
        Gizmos2D.drawSolidEllipse(this.node, this._portLeft.worldPosition, 20, 30);
        Gizmos2D.drawSolidEllipse(this.node, this._portRight.worldPosition, 20, 30);
    }

    protected onLoad(): void {
        this._fxPool = new ObjectPool(this._fx, 2, true);
        this._collider.on(Contact2DType.BEGIN_CONTACT, this.onBeginContact, this);
        EventManger.instance.on(GameEvent.SpawnMultiBall, this.spawnBall, this);
    }

    protected lateUpdate(dt: number): void {
        if (this._trigged) {
            CameraController.instance.shake(0.3);
            const ball1 = this._originBall;
            ball1.clearRigiState(false);
            const ball2 = GameManager.instance.spawnBall(false, false);
            ball2.clearRigiState(false);

            ball1.node.setWorldPosition(this._portRight.worldPosition);
            ball1.clearRigiState(true);
            ball1.addForce(new Vec2(50, 0));

            ball2.node.setWorldPosition(this._portLeft.worldPosition);
            ball2.clearRigiState(true);
            ball2.addForce(new Vec2(-50, 0));

            this._trigged = false;
        }
    }

    public async spawnBall(quantity: number) {
        CameraController.instance.shake(0.3);
        this._colliderEnabled = false;
        for (let i = 0; i < quantity; i++) {
            const ball = GameManager.instance.spawnBall(false, false);
            if (i % 2 == 0) {
                ball.node.setWorldPosition(this._portRight.worldPosition);
                ball.addForce(new Vec2(40, 0));
            } else {
                ball.node.setWorldPosition(this._portLeft.worldPosition);
                ball.addForce(new Vec2(-40, 0));
            }
        }

        const fx = this._fxPool.get(ParticleSystem, GameManager.instance.topContainer);
        const pos = this.node.getWorldPosition();
        pos.z = 10;
        fx.node.setWorldPosition(pos);
        AudioManager.playSfx(this._soundFX);
        await Utils.delay(TimeConfig.DelayMultiBall);
        this._colliderEnabled = true;
        await Utils.waitUntil(() => fx.isStopped);
        this._fxPool.release(fx);
    }

    private async onBeginContact(selfCollider: Collider2D, otherCollider: Collider2D) {
        if (!this._colliderEnabled) return;
        if (this._trigged) return;
        this._colliderEnabled = false;
        this._originBall = otherCollider.getComponent(Ball);
        this._trigged = true;
        const fx = this._fxPool.get(ParticleSystem, GameManager.instance.topContainer);
        const pos = this.node.getWorldPosition();
        pos.z = 10;
        fx.node.setWorldPosition(pos);
        AudioManager.playSfx(this._soundFX);
        await Utils.delay(TimeConfig.DelayMultiBall);
        this._colliderEnabled = true;
        await Utils.waitUntil(() => fx.isStopped);
        this._fxPool.release(fx);
    }
}