ブロックくずしを作る７「ブロックを配置する」

export class Brick implements IGameCanvasPart {
    /**
     * ブロック本体の四角
     */
    private _body = new Rectangle(0, 0,
        GameParameter.Brick.Width, GameParameter.Brick.Height);

    /**
     * ブロックの中心のX座標
     */
    public get X() {
        return this._body.X;
    }
    public set X(value) {
        this._body.X = value;
    }

    /**
     * ブロックの中心のYY座標
     */
    public get Y() {
        return this._body.Y;
    }
    public set Y(value) {
        this._body.Y = value;
    }
}

import { IGameCanvasPart } from './game/GameCanvasPart';
import { Brick } from './Brick';
import { GameMng } from './GameMng';
import { Rectangle } from './shape/Rectangle';
import { GameParameter } from './GameParameter';
import { ISize } from './shape/ISize';
/**
 * ブロックセットクラス
 * 
 * 全てのBrickを管理するクラス
 */
export class BrickSet implements IGameCanvasPart {
    /**
     * ブロック
     */
    private _brickList: Brick[] = [];

    /**
     * コンストラクタ
     */
    constructor(private _game: GameMng) {
    }

    /**
     * ブロックの並びの列（横方向）の数
     */
    private _numberOfColumn = 0;

    /**
     * ブロックの並びの行（縦方向）の数
     */
    private _numberOfRow = 0;

    /**
     * 全ブロックを配置するエリアの長方形
     */
    private _areaToPlaceBricks = new Rectangle(0, 0, 0, 0);

    /**
     * ゲーム開始時の初期化処理
     */
    public Init() {
        let gameArea = this._game.Area;
        if (gameArea === undefined) {
            throw new Error("gameArea が未定義です。");
        }
        let bw = GameParameter.Brick.Width;
        let bh = GameParameter.Brick.Height;
        let bg = GameParameter.Brick.Gap;

        // _ブロックの並びの行列の数を計算する
        this._numberOfColumn = Math.floor((gameArea.Width + bg) / (bw + bg));
        this._numberOfRow = Math.floor(gameArea.Height / (bh + bg) / 3);

        // 全ブロックを並べて配置したときの全体的な四角形の横幅と高さを算出する
        let width = (bw + bg) * this._numberOfColumn - bg;
        let height = (bh + bg) * this._numberOfRow - bg;

        // 全ブロックを配置するエリアを設定する
        this._areaToPlaceBricks.Width = width;
        this._areaToPlaceBricks.Height = height;
        this._areaToPlaceBricks.X = gameArea.X;
        this._areaToPlaceBricks.Y = gameArea.Top + bg + height / 2;

        // _brickListを更新する。
        this._updateBrickList();
    }

    /**
     *  _brickListを更新する。
     * 
     * 一度空にクリアし、新たにブロックを作成して登録する。
     */
    private _updateBrickList() {
        let bw = GameParameter.Brick.Width;
        let bh = GameParameter.Brick.Height;
        let bg = GameParameter.Brick.Gap;

        // brick0(最も左上のブロック)の座標を算出する。
        let brick0 = {
            X: this._areaToPlaceBricks.Left + bw / 2,
            Y: this._areaToPlaceBricks.Top + bh / 2,
        };

        // ブロックを新たに作成する
        this._brickList = [];
        for (let row = 0; row < this._numberOfRow; row++) {
            for (let col = 0; col < this._numberOfColumn; col++) {
                let brick = new Brick(this._game);
                this._brickList.push(brick);
                brick.X = brick0.X + (bw + bg) * col;
                brick.Y = brick0.Y + (bh + bg) * row;
                // ブロックの位置に応じて、色を変える。
                // デバッグを兼ねたお試しコードなので、将来変更する可能性あり
                if (row < this._numberOfRow / 4) {
                    brick.Color = "red";
                }
                else if (row < this._numberOfRow / 2) {
                    brick.Color = "yellow";
                }
            }
        }
    }

    Update(): void {
    }

    DrawCanvas(context: CanvasRenderingContext2D): void {
        this._brickList.forEach(brick => brick.DrawCanvas(context));
    }

    /**
     * ブロックセットの観点から算出する、ゲームエリアの最小サイズ
     */
    public static get MinimumSizeOfGameArea(): ISize {
        let bw = GameParameter.Brick.Width;
        let bh = GameParameter.Brick.Height;
        let bg = GameParameter.Brick.Gap;
        let minColumn = GameParameter.Brick.MinColumn;
        let minRow = GameParameter.Brick.MinRow;
        return {
            Width: minColumn * (bw + bg) - bg,
            Height: 3 * minRow * (bh + bg),
        };
    }
}

/**
 * ゲームパラメーター
 */
export const GameParameter = {
    /**
     * ゲームエリアに関連するパラメーター
     */
    GameArea: {
        /**
         * ゲームエリアの上下左右のmargin値
         */
        Margin:{
            Top: 20,
            Bottom: 40,
            Left: 20,
            Right: 20,
        } as const,
    } as const,

    /**
     * ブロックに関連するパラメーター
     */
    Brick: {
        /**
         * ブロックの横幅
         */
        Width: 28,
        /**
         * ブロックの縦幅
         */
        Height: 13,
        /**
         * ブロックの間隔
         */
        Gap: 2,
        /**
         * ブロックの並びの横の列の最低数
         */
        MinColumn: 5,
        /**
         * ブロックの並びの縦の行の最低数
         */
        MinRow: 3,
    } as const,
} as const;

export class GameMng extends GameLoop {
    /**
     * ブロック
     */
    public BrickSet = new BrickSet(this);

    /**
     * コンストラクタ
     */
    constructor() {
        super();
        // 部品を登録
        this.AddPart(this.Canvas);

        // CANVAS部品を登録
        // ゲームエリア（を示す枠）
        let tmp = new GameCanvasPart();
        tmp.onDrawCanvas = context => {
            if (this.Area) {
                context.strokeStyle = "white";
                context.strokeRect(this.Area.Left, this.Area.Top, this.Area.Width, this.Area.Height);
            }
            else {
                let text = `ゲームエリアを設定できません。`;
                context.strokeStyle = "red";
                context.strokeText(text, 0, 12);
            }
        }
        this.Canvas.AddPart(tmp);
        // 球
        this.Canvas.AddPart(this.Ball);
        // ラケット
        this.Canvas.AddPart(this.Racket);
        // ブロック
        this.Canvas.AddPart(this.BrickSet);

        this._AfterReadyCanvas();
    }

    /**
     * ゲームの状態を初期化する
     */
    public InitSituation() {
        // 球を初期化する
        this.Ball.Init();

        // ラケットを初期化する。
        this.Racket.Init();

        // ブロックを初期化する。
        this.BrickSet.Init();
    }

    /**
     * ゲームキャンバスの準備ができてから行なう処理
     */
    private async _AfterReadyCanvas() {
        await this.Canvas.WaitUntil_GetHtmlElement();
        let width = this.Canvas.Width;
        let height = this.Canvas.Height;

        // キャンバスの最小サイズを計算する
        let minSize = this._GetMinimumSizeOfCanvas();

        // キャンバスサイズが最小サイズ以上なら、ゲームエリアを作成する
        if (width >= minSize.Width && height >= minSize.Height) {
            let margin = GameParameter.GameArea.Margin;
            this.Area = new Rectangle(
                margin.Left, margin.Top,
                width - margin.Right, height - margin.Bottom);

            // ゲーム状態の初期化
            this.InitSituation();
        }
    }

    /**
     * キャンバスの最小サイズを計算する。
     * @returns キャンパスの最小サイズ
     */
    private _GetMinimumSizeOfCanvas(): ISize {
        let margin = GameParameter.GameArea.Margin;
        let minGameArea = BrickSet.MinimumSizeOfGameArea;
        return {
            Width: margin.Left + margin.Right + minGameArea.Width,
            Height: margin.Top + margin.Bottom + minGameArea.Width,
        };
    }
}