【ぷよプロ】ぷよぷよプログラミングを始めよう（開発編⑤）- モードの処理を実装してゲームを完成させよう（前半）

case 'start':
// 最初は、もしかしたら空中にあるかもしれないぷよを自由落下させるところからスタート
mode = 'checkFall';
break;

case 'checkFall':
// 落ちるかどうか判定する
if(Stage.checkFall()) {
	mode = 'fall';
} else {
// 落ちないならば、ぷよを消せるかどうか判定する
	mode = 'checkErase';
}
break;

// 自由落下をチェックする
    static checkFall() {
        this.fallingPuyoList.length = 0;
        let isFalling = false;
        // 下の行から上の行を見ていく
        for(let y = Config.stageRows - 2; y >= 0; y--) { 
            const line = this.board[y];
            for(let x = 0; x < line.length; x++) {
                if(!this.board[y][x]) {
                    // このマスにぷよがなければ次
                    continue;
                }
                if(!this.board[y + 1][x]) {
                    // このぷよは落ちるので、取り除く
                    let cell = this.board[y][x];
                    this.board[y][x] = null;
                    let dst = y;
                    while(dst + 1 < Config.stageRows && this.board[dst + 1][x] == null) {
                        dst++;
                    }
                    // 最終目的地に置く
                    this.board[dst][x] = cell;
                    // 落ちるリストに入れる
                    this.fallingPuyoList.push({
                        element: cell.element,
                        position: y * Config.puyoImgHeight,
                        destination: dst * Config.puyoImgHeight,
                        falling: true
                    });
                    // 落ちるものがあったことを記録しておく
                    isFalling = true;
                }
            }
        }
        return isFalling;
    }

case 'fall':
if(!Stage.fall()) {
    // すべて落ちきったら、ぷよを消せるかどうか判定する
    mode = 'checkErase';
}
break;

// 自由落下させる
    static fall() {
        let isFalling = false;
        for(const fallingPuyo of this.fallingPuyoList) {
            if(!fallingPuyo.falling) {
                // すでに自由落下が終わっている
                continue;
            }
            let position = fallingPuyo.position;
            position += Config.freeFallingSpeed;
            if(position >= fallingPuyo.destination) {
                // 自由落下終了
                position = fallingPuyo.destination;
                fallingPuyo.falling = false;
            } else {
                // まだ落下しているぷよがあることを記録する
                isFalling = true;
            }
            // 新しい位置を保存する
            fallingPuyo.position = position;
            // ぷよを動かす
            fallingPuyo.element.style.top = position + 'px';
        }
        return isFalling;
    }

case 'checkErase':
// 消せるかどうか判定する
const eraseInfo = Stage.checkErase(frame);
if(eraseInfo) {
    mode = 'erasing';
    combinationCount++;
    // 得点を計算する
    Score.calculateScore(combinationCount, eraseInfo.piece, eraseInfo.color);
    Stage.hideZenkeshi();
} else {
    if(Stage.puyoCount === 0 && combinationCount > 0) {
        // 全消しの処理をする
        Stage.showZenkeshi();
        Score.addScore(3600);
    }
    combinationCount = 0;
    // 消せなかったら、新しいぷよを登場させる
    mode = 'newPuyo'
}
break;

// 消せるかどうか判定する
static checkErase(startFrame) {
    this.eraseStartFrame = startFrame;
    this.erasingPuyoInfoList.length = 0;

    // 何色のぷよを消したかを記録する
    const erasedPuyoColor = {};

    // 隣接ぷよを確認する関数内関数を作成
    const sequencePuyoInfoList = [];
    const existingPuyoInfoList = [];
    const checkSequentialPuyo = (x, y) => {
        // ぷよがあるか確認する
        const orig = this.board[y][x];
        if(!orig) {
            // ないなら何もしない
            return;
        }
        // あるなら一旦退避して、メモリ上から消す
        const puyo = this.board[y][x].puyo;
        sequencePuyoInfoList.push({
            x: x,
            y: y,
            cell: this.board[y][x]
        });
        this.board[y][x] = null;

        // 四方向の周囲ぷよを確認する
        const direction = [[0, 1], [1, 0], [0, -1], [-1, 0]];
        for(let i = 0; i < direction.length; i++) {
            const dx = x + direction[i][0];
            const dy = y + direction[i][1];
            if(dx < 0 || dy < 0 || dx >= Config.stageCols || dy >= Config.stageRows) {
                // ステージの外にはみ出た
                continue;
            }
            const cell = this.board[dy][dx];
            if(!cell || cell.puyo !== puyo) {
                // ぷよの色が違う
                continue;
            }
            // そのぷよのまわりのぷよも消せるか確認する
            checkSequentialPuyo(dx, dy);
            
        };
    };
    
    // 実際に削除できるかの確認を行う
    for(let y = 0; y < Config.stageRows; y++) {
        for(let x = 0; x < Config.stageCols; x++) {
            sequencePuyoInfoList.length = 0;
            const puyoColor = this.board[y][x] && this.board[y][x].puyo;
            checkSequentialPuyo(x, y);
            if(sequencePuyoInfoList.length == 0 || sequencePuyoInfoList.length < Config.erasePuyoCount) {
                // 連続して並んでいる数が足りなかったので消さない
                if(sequencePuyoInfoList.length) {
                    // 退避していたぷよを消さないリストに追加する
                    existingPuyoInfoList.push(...sequencePuyoInfoList);
                }
            } else {
                // これらは消して良いので消すリストに追加する
                this.erasingPuyoInfoList.push(...sequencePuyoInfoList);
                erasedPuyoColor[puyoColor] = true;
            }
        }
    }
    this.puyoCount -= this.erasingPuyoInfoList.length;

    // 消さないリストに入っていたぷよをメモリに復帰させる
    for(const info of existingPuyoInfoList) {
        this.board[info.y][info.x] = info.cell;
    }

    if(this.erasingPuyoInfoList.length) {
        // もし消せるならば、消えるぷよの個数と色の情報をまとめて返す
        return {
            piece: this.erasingPuyoInfoList.length,
            color: Object.keys(erasedPuyoColor).length
        };
    }
    return null;
    }

static calculateScore (rensa, piece, color) {
        rensa = Math.min(rensa, Score.rensaBonus.length - 1);
        piece = Math.min(piece, Score.pieceBonus.length - 1);
        color = Math.min(color, Score.colorBonus.length - 1);
        let scale = Score.rensaBonus[rensa] + Score.pieceBonus[piece] + Score.colorBonus[color];
        if(scale === 0) {
            scale = 1;
        }
        this.addScore(scale * piece * 10);
    }

case 'erasing':
if(!Stage.erasing(frame)) {
    // 消し終わったら、再度落ちるかどうか判定する
    mode = 'checkFall';
}
break;

// 消すアニメーションをする
static erasing(frame) {
const elapsedFrame = frame - this.eraseStartFrame;
const ratio = elapsedFrame / Config.eraseAnimationDuration;
if(ratio > 1) {
    // アニメーションを終了する
    for(const info of this.erasingPuyoInfoList) {
        var element = info.cell.element;
        this.stageElement.removeChild(element);
    }
    return false;
} else if(ratio > 0.75) {
    for(const info of this.erasingPuyoInfoList) {
        var element = info.cell.element;
        element.style.display = 'block';
    }
    return true;
} else if(ratio > 0.50) {
    for(const info of this.erasingPuyoInfoList) {
        var element = info.cell.element;
        element.style.display = 'none';
    }
    return true;
} else if(ratio > 0.25) {
    for(const info of this.erasingPuyoInfoList) {
        var element = info.cell.element;
        element.style.display = 'block';
    }
    return true;
} else {
    for(const info of this.erasingPuyoInfoList) {
        var element = info.cell.element;
        element.style.display = 'none';
    }
    return true;
}
    }