85727
提示コードですがテトリスでブロックが一列揃ったら点滅(エフェクト)して消えてラインを詰めるという処理なのですがこの際にフラグという処理の作り方をしているのですがこれは正しいのでしょうか？
提示コードのコンストラクタ部の` /* ### エフェクト ###*/`,`/*## 削除 ##*/`部の `bool`型変数のフラグの多さが気がかりです。

利用ライブラリ: <https://p5js.org/>

Game.js

```

          // ################################ エフェクト ################################ 
          Effect()
          {
                if( (this.clearLine.length > 0) && (this.isEffect == true) )
                {
    
                      this.blink_Time += deltaTime;
                      if(this.blink_Time > BLINKING_INTERVAL)
                      {
                            this.isBlink = !this.isBlink;
                            this.blink_Time = 0;
    
                            this.blinkCount++;
                            if(this.blinkCount > BLICK_COUNT)
                            {
                                  this.blinkCount = 0;
                                  this.isEffect = false;
                                  this.isNewBlock = true;
                                  this.isBlink = false;
                                  this.isShiftLine = true;
                                  this.setReset();
                            }
                      }
                }
                else
                {
                      this.isPutBlock = false;
                }
          }
    
          // ################################ ライン 詰める ################################ 
          ShiftLine(stage)
          {
                if(this.isShiftLine == true)
                {
                      let count = 0;
                      for(let y = 0; y < STAGE_HEIGHT; y++)
                      {
                            count = 0;
                            for(let x = 0; x < STAGE_WIDTH; x++)
                            {
                                  if( (stage[y][x] != WALL) && (stage[y][x] != NONE) )
                                  {
                                        count++;
                                  }
                            }
    
                            if(count == LINE)
                            {
                                  for(let x = 1; x < STAGE_WIDTH; x++)
                                  {
                                        for(let yy = y; yy > 0; yy--)
                                        {
                                              stage[yy][x] = stage[yy - 1][x];
    
                                        }
                                  }
                            }
                      }
    
                      this.isShiftLine = false;
                }
          }      
          // ################################ ライン削除 取得 ################################ 
          ClearLine(stage)
          {
                if(this.isPutBlock == true && this.isCearLine == false )
                {
                      for(let y = 0; y < STAGE_HEIGHT; y++)
                      {
                            let count = 0;
                            let temp = new Array(0);
                            for(let x = 1; x < STAGE_WIDTH; x++)
                            {
                                  if( (stage[y][x] != WALL) && (stage[y][x] != NONE) )
                                  {
                                        temp.push(new Vector(x,y));
                                        count++;
                                  }
                                  else
                                  {
                                        break;
                                  }
                            }
    
                            if(count == LINE)
                            {
                                  this.clearLine.push(y);
                            }
                            
                      }
                      
                      if(this.clearLine.length > 0)
                      {
                            this.isEffect = true;
                            this.isCearLine = true;
                      }
                      else
                      {
                            this.isPutBlock == false;
                            this.isNewBlock = true;
                      }
                }
    
                this.Effect();    //エフェクト
          }
    
    
          // ################################ コンストラクタ ################################ 
          constructor()
          {            
                /* ########## 現在　ブロック ########## */
                this.nowBlock = 
                [
                      [0,0,0,0],
                      [0,0,0,0],
                      [0,0,0,0],
                      [0,0,0,0]
                ];
    
          
                       
                /* ########## 次の　ブロック ########## */
                this.nextBlock = 
                [
                      [0,0,0,0],
                      [0,0,0,0],
                      [0,0,0,0],
                      [0,0,0,0]
                ];
    
                /* ########## ブロック ########## */
                this.blockNumber;                                                       //現在のブロック
                this.nextBlockNumber = Math.floor(random(2,7)) - BLOCK_COLOR;           //次のブロック
    
                this.position;
                
                /* ########## 落下 ########## */
                this.down_Time = 0;
                this.downHit = false;
                this.put_Time = 0;
    
                /* ########## 削除ライン ########## */
                this.isPutBlock = false;      //ブロックを置くかどうか？
                this.isNewBlock = true;       //新しいブロックを出すかどうか？
                this.isCearLine = false;      //詰めるラインを算出するかどか？
                this.isShiftLine = false;     //ラインを詰めるかどうか？
    
                /* ########## 入力  ########## */
                this.isPushSpaceKey = false;
                this.isHoldSpaceKey = false;
                this.isPushRightKey = false;
                this.isHoldRightKey = false;
                this.isPushLeftKey = false;
                this.isHoldLeftKey = false;                        
    
                /* ########## エフェクト ########## */
                this.isEffect = false;
                this.isBlink = false;
                this.blink_Time = 0;
                this.blinkCount = 0;
                this.nowDeleteLine = false;
                this.clearLine = [];      //削除ライン
    
    
                /* ########## 回転 ########## */
                this.rotate = 0;
                this.isRotate = false;
    
                this.setReset();  //ブロック生成
          }
    
          // ################################ ブロック生成 ################################ 
          setReset()
          {
                if( (this.isNewBlock == true) && (this.isEffect == false) )
                {
                      this.rotate = 0;
                      this.clearLine.length = 0;
                      this.isCearLine = false;
                      this.isEffect = false;
                      this.isPutBlock = false;
                      this.position = new Vector(START_BLOCK_POSITION_X,START_BLOCK_POSITION_Y);
                      this.blockNumber = this.nextBlockNumber;
                      this.nextBlockNumber = Math.floor(random(2,7)) - BLOCK_COLOR;
    
    //                  this.blockNumber = Math.floor(random(2,7)) - BLOCK_COLOR;
                      
    
    
                      //ブロック クリア
                      for(let y = 0; y < BLOCK_HEIGHT; y++)
                      {
                            for(let x = 0; x < BLOCK_WIDTH; x++)
                            {
                                  this.nowBlock[y][x] = 0;
                            }
                      }
    
                      //ブロック設定
                      for(let y = 0; y < BLOCK_HEIGHT; y++)
                      {
                            for(let x = 0; x < BLOCK_WIDTH; x++)
                            {
                                  this.nowBlock[y][x] = blockPattern[this.blockNumber][y][x];
                            }
                      }
                      
                      this.isNewBlock = false;
                }
    
          }
    
    
```
CC BY-SA 4.0
2022-01-15T12:29:51.917
85713
2022-01-20T03:24:47.233
2022-01-20T03:24:47.233
2238
question
javascript
ループ構造におけるフラグ判定の正しい使い方
自分はテトリスの回転を再現したのですがこのサイトにより配列の左上に詰めるのではなくルールによって分けれており各ブロックに対する個別の処理を記述する必要があるとのことなので解決しました。

テトリスの回転ルール <https://tetrisch.github.io/main/srs.html>
CC BY-SA 4.0
2022-01-16T05:29:05.200
85727
2022-01-16T05:29:05.200
85713
answer