anchor.diff:    }
   
     /**
  -   * Triggered periodic by a Timer from the Controller, ...
  -   *
  +   * Triggered periodic by a Timer from the Controller, and push the
  +   * complete field up and check afterwards of Game Over
      */
     void timerFieldUp()
     {
  -
  -
  +    // Move the Field up and update the Position of the Blocks
  +    for(int y = (_fieldY - 1); y >= 0; y--)
  +    {
  +      for(int x = 0; x < _fieldX; x++)
  +      {
  +        // move block [x][y] up
  +        _field[x][y + 1] = _field[x][y];
  +        // update the Position of the moved Block
  +        _field[x][y + 1].setPos(new Point(x,y + 1));
  +        // delete Block at the old Position
  +        _field[x][y] = null;
  +      }
  +    }
  +
  +    // check for Game Over
  +    for(int r = 0; r < _fieldX; r++)
  +    {
  +      if(_field[r][_fieldY] != null)
  +      {
  +        // a Block reached the upper Border of the play field
  +        // Raise Game Over Event
  +        fetch(eventType.GameOver);
  +      }
  +    }
  +
  +    throw new Exception("not tested yet");
  +  }
  +
  +  /**
  +   * Triggered periodic by a Timer from the Controller, and increase
  +   * the Level Time and check for Win or Game Over
  +   */
  +  void increaseLevelTime()
  +  {
  +    // Count the Level Time up
  +    _currentLevelTime++;
  +
  +    // Check if the end of the level reached
  +    if(_currentLevelTime >= _level.getLevelTime())
  +    {
  +      // Check if the required score reached
  +      if(_currentScore >= _level.getRequiredScore())
  +      {
  +        // Raise Win Event
  +        fetch(eventType.Win);
  +      }
  +      else
  +      {
  +        // Raise Game Over Event
  +        fetch(eventType.GameOver);
  +      }
  +    }
  +
  +    throw new Exception("not tested yet");
  +  }
  +
  +  /**
  +   * Triggered periodic by a Timer from the Controller, check at
  +   * every Block if this Block can fall and move it down.
  +   */
  +  void timerApplyGravity()
  +  {
  +    bool somethingFalling = false;
  +    //
  +    for(int y = (1 + unusableRows); y < _fieldY; y++)
  +    {
  +      for(int x = 0; x < _fieldX; x++)
  +      {
  +        // check if the block can fall
  +        if(isValidCoords(new Point(x,y - 1)))
  +        {
  +          if(_field[x][y - 1] == null)
  +          {
  +            _field[x][y].setFalling(true);
  +            _field[x][y].setIsLocked(true);
  +          }
  +        }
  +
  +        // if block falling
  +        if(_field[x][y].isFalling())
  +        {
  +          // move Block down (falling)
  +          _field[x][y - 1] = _field[x][y];
  +          // delete old Block Position
  +          _field[x][y] = null;
  +
  +          // check if under the new position of the moved block a other block available
  +          if(isValidCoords(new Point(x,y - 2)))
  +          {
  +            if(_field[x][y - 2] != null)
  +            {
  +              // Only remove states if locked and falling both true,
  +              // secure the option if blocks are locked cause of a combo
  +              if(_field[x][y - 1].isFalling() && _field[x][y - 1].isLocked())
  +              {
  +                _field[x][y - 1].setFalling(false);
  +                _field[x][y - 1].setIsLocked(false);
  +              }
  +            }
  +          }
  +          // at least one block is still falling
  +          somethingFalling = true;
  +        }
  +      } // end of for loop
  +
  +      // Only execute the dissolve trigger if no more blocks are falling
  +      if(!somethingFalling) _triggerDissolve();
  +    }
   
       throw new Exception("not implemented yet");
     }
  -
  -
  -  void DecreaseLevelTime()
  -  {
  -
  -
  -
  -    throw new Exception("not implemented yet");
  -  }
  -
  -
  -  void timerApplyGravity()
  -  {throw new Exception("not implemented yet");}
   
     /**
      * Check a coordinate are valid
  
positive.code: import "dart:collection";
  import "Command.dart";
  import "Block.dart";
  import "dart:math";
  import "Level.dart";
  import "Cursor.dart";
  
  class Playfield
  {
    List<List<Block>> _field;
    Queue<Command> _actionQueue = new Queue<Command>();
    //Streamcontroller hier kommt der eventhandler hin
    double _currentScore;
    int _currentLevelTime;
    List<Block> _toDissolve;
    int _fieldX;
    int _fieldY;
  
negative.code:         for(int y = currentBlockPos.y; y < _fieldY; y++)
          {
            _field[currentBlockPos.x][y].setFalling(true);
            _field[currentBlockPos.x][y].setIsLocked(true);
          }
  
          // add Points to Score
  