pinball/assets/_Game/Scripts/Manager/GameManager.ts

import { _decorator, Component, Prefab, Node, Vec2, Vec3, randomRangeInt, CCInteger, Input } from 'cc';
import ObjectPool from '../Pool/ObjectPool';
import { Ball } from '../Gameplay/Ball';
import Utilities from '../Utilities/Utilities';
import GameState from '../Enum/GameState';
import { EventManger } from './EventManger';
import GameEvent from '../Events/GameEvent';
import ScoreType from '../Enum/ScoreType';
const { ccclass, property } = _decorator;

@ccclass('GameManager')
export class GameManager extends Component {
    //singleton
    private static _instance: GameManager = null;
    public static get instance(): GameManager {
        return GameManager._instance;
    }

    @property({ type: Prefab, visible: true })
    private _ballPrefab: Prefab;

    @property({ visible: true })
    private _ballSpawnPosition: Vec3;
    @property({ type: CCInteger, visible: true })
    private _balls = 3;

    private _ballPool: ObjectPool;
    private _gameState = GameState.Init;

    public highestStreak: number;
    private _score = 0;

    protected onLoad(): void {
        GameManager._instance = this;
        this._ballPool = new ObjectPool(this._ballPrefab, 10, true, Ball);
    }

    protected start() {
        this.spawnBall();
    }

    private changeGameState(state: GameState) {
        this._gameState = state;
        EventManger.instance.emit(GameEvent.GameStateChange, this._gameState);
    }

    private addScore(score: number, type: ScoreType) {
        this._score += score;
        console.log('score:' + this._score);
        EventManger.instance.emit(GameEvent.Score, [type, this._score]);
    }

    public spawnBall(): Ball {
        const ball = this._ballPool.get(this.node, Ball);
        ball.node.setPosition(this._ballSpawnPosition);
        let dir = randomRangeInt(-1, 2);
        while (dir == 0) {
            dir = randomRangeInt(-1, 2);
        }
        const force = new Vec2(dir, 1);
        ball.throwBall(force.multiply2f(1, 40));
        return ball;
    }

    public async ballOut(ball: Node) {
        this._balls--;
        this._ballPool.release(ball);
        if (this._balls === 0) {
            return;
        }
        await Utilities.delay(1000);
        this.spawnBall();
    }

    public async goal(bonusScore: number, ball: Node) {
        this._ballPool.release(ball);
        this.addScore(bonusScore, ScoreType.Goal);
        await Utilities.delay(1000);
        this.spawnBall();
    }

    public destroyEnviromentsObject(bonusScore: number) {
        this.addScore(bonusScore, ScoreType.DestroyObject);
    }

    public onRevive() {
        throw new Error('Method not implemented.');
    }
}