pinball/assets/_Game/Scripts/UI/GameOverPanel.ts

import { _decorator, AudioClip, Component, Label, Node, Prefab, randomRange, Tween, tween, Vec3 } from 'cc';
import BEConnector from '../API/BEConnector';
import { GameManager } from '../Manager/GameManager';
import ObjectPool from '../Pool/ObjectPool';
import Utilities from '../Utilities';
import { EventManger } from '../Manager/EventManger';
import GameEvent from '../Events/GameEvent';
import GameState from '../Enum/GameState';
import { SoundManager } from '../Manager/SoundManager';
const { ccclass, property } = _decorator;

@ccclass('GameOverPanel')
export class GameOverPanel extends Component {
    @property(Label) private topScore: Label = null;
    @property(Label) private yourScore: Label = null;

    @property({ type: Label, visible: true })
    private _ticketMinus: Label;

    @property({ type: Node, visible: true })
    private _buyTicketBtn: Node;
    @property({ type: Node, visible: true })
    private _quitBtn: Node;

    @property({ type: Node, visible: true })
    private _scoreUI: Node;
    @property({ type: Prefab, visible: true })
    private _scorePrefab: Prefab;

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

    private _pool: ObjectPool;
    private _active = false;
    private _clicked = false;
    private _end = false;

    protected onLoad(): void {
        this._pool = new ObjectPool(this._scorePrefab, 100, true);
        EventManger.instance.on(GameEvent.GameStateChange, this.onGameStateChange, this);
    }

    protected onEnable(): void {
        this._ticketMinus.string = '-' + BEConnector.instance.getTicketCanBeMinus().toString();
        this.topScore.string = BEConnector.instance.maxScore.toString();
        this.yourScore.string = BEConnector.instance.currentScore.toString();
        const gameScore = GameManager.instance.score;
        const currentScore = BEConnector.instance.currentScore;
        this.playCollectEffect(gameScore, currentScore);
        this.scheduleOnce(this.endGame, 60);
        this._active = true;
    }

    private async onGameStateChange(state: GameState) {
        switch (state) {
            case GameState.Init:
                break;
            case GameState.Ready:
                break;
            case GameState.Playing:
                break;
            case GameState.GameOver:
                break;
            case GameState.End:
                this._buyTicketBtn.active = false;
                this._quitBtn.active = false;
                this._end = true;
                if (this._active) {
                    await Utilities.delay(1);
                    BEConnector.instance.postScoreToServer();
                }
                break;
            case GameState.Relive:
                break;
        }
    }

    onClickYesButton() {
        if (this._clicked) return;
        this._clicked = true;
        if (BEConnector.instance.canRelive()) {
            BEConnector.instance
                .checkGameScoreTicket()
                .then(() => {
                    this._clicked = false;
                    GameManager.instance.gameRelive();
                })
                .catch(() => {
                    this._clicked = false;
                    GameManager.instance.gameOver();
                });
        } else {
            this._clicked = false;
            BEConnector.instance.postMessage();
        }
    }

    onClickNoButton() {
        GameManager.instance.gameOver();
    }

    protected onDisable(): void {
        this._active = false;
        this.unschedule(this.endGame);
    }

    private endGame() {
        GameManager.instance.gameOver();
    }

    private async playCollectEffect(gameScore: number, currentScore: number) {
        if (!this._active) {
            let x = 10;
            let items = Math.ceil(gameScore / x);
            if (items >= 50) {
                items = 50;
                x = Math.round(gameScore / items);
            }
            const time = 0.04;
            const totalScore = gameScore + currentScore;
            let score = currentScore;
            const target = this.yourScore.node.getWorldPosition();
            for (let i = 0; i < items; i++) {
                score += x;
                score = score > totalScore ? totalScore : score;
                const obj = this._pool.get(this._scoreUI);
                obj.setWorldPosition(this._scoreUI.worldPosition);
                tween(obj)
                    .to(randomRange(0.2, 0.3), { worldPosition: target }, { easing: 'sineIn' })
                    .call(() => this._pool.release(obj))
                    .call(() => {
                        Tween.stopAllByTarget(this.yourScore);
                        tween(this.yourScore.node)
                            .to(0.1, { scale: new Vec3(1.3, 1.3, 1.3) })
                            .call(async () => {
                                if (i == items - 1) {
                                    this.yourScore.string = totalScore.toString();
                                    if (this._end) {
                                        await Utilities.delay(1);
                                        BEConnector.instance.postScoreToServer();
                                    }
                                } else {
                                    this.yourScore.string = score.toString();
                                }
                            })
                            .set({ scale: Vec3.ONE })
                            .start();
                    })
                    .start();
                SoundManager.instance.playSfx(this._soundCollectCoinFx);
                await Utilities.delay(time);
            }
        }
    }
}