anchor.diff:    List<Map<String, int>> get parts => _parts;
   
     int get hitpoints => this._hitpoints;
  -    
  +
     /**
      * Überprüft dieses [Ship] drauf, ob es sich auf dem gleichen Feld wie ein [Projectile] befindet.
      * Wenn ja, werden die [_hitpoints] von diesem [Ship] um 1 reduziert und das [Projectile] entfernt.
      */
  -  void detectCollision(){
  +  void detectCollision() {
       List<Projectile> projectiles = this._model.projectiles.toList();
  -    for(Map<String, int> part in this._parts){
  -      for(Projectile prj in projectiles){
  -        if((part['row'] == prj._coordinate['row']) && (part['col'] == prj._coordinate['col'])){
  +    for (Map<String, int> part in this._parts) {
  +      for (Projectile prj in projectiles) {
  +        if ((part['row'] == prj._coordinate['row']) &&
  +            (part['col'] == prj._coordinate['col'])) {
             print('Hit by enemy! Reducing HP by 1');
             this.reduceHitpointsBy(1);
             this._model.removeProjectile(prj);
  
positive.code:  * Bewegt sich nur bei Nutzereingabe
   */
  class PlayerShip extends Ship {
      
    PlayerShip(SpaceInvaderModel model, List<Map<String, int>> parts, int hitpoints) : super(model, parts, hitpoints);
    /**
     * Mthode um das [PlayerShip] zu bewegen.
     * Vor jeder Bewegung wird auf Kollision geprüft.
     */
    void move(String direction){
      switch(direction){
        case 'left':
        
          if(this._leftMost['col'] == 0) { print('Cant move left anymore');
          
          break; }
          else {
            for(Map coor in parts){
              coor['col'] -= 1;
              
              if(coor['col'] < this._leftMost['col']) this._leftMost = coor;
            }
            
          print('moved player left');
          }
          break;
        case 'right':
        
          if(this._rightMost['col'] == gamesize-1) { print('Cant move right anymore');
          
          break; }
          else {
            for(Map coor in parts){
              coor['col'] += 1;
             
              if(coor['col'] > this._rightMost['col']) this._rightMost = coor; 
            }
            
          print('moved player right');
          }
          break;
      }
      detectCollision();
    }
    
    /**
     * Jede Kanone in [_cannons] schießt eine Kugel mit Richtung -1 ab
     * (Das [Projectile] fliegt nach oben)
     */
    shoot(){
      for(Map<String, int> coor in _cannons){
        this._model.spawnProjectile({'row': (coor['row']-1), 'col': coor['col'], 'dir': -1});
      }
    }
    
    reduceHitpointsBy(int damage){
       this._hitpoints -= damage;
       
       if(this._hitpoints <= 0) {
         this._hitpoints = 0;
         _model.setGameOver();
         print('PlayerShip is destroyed!');
       }
     }
    
    setup(){
      
      this._leftMost = _parts[0];
      this._rightMost = _parts[0];
      
      for(Map coor in _parts){
        if(coor['col'] < _leftMost['col']) this._leftMost = coor; 
        if(coor['col'] > _rightMost['col']) this._rightMost = coor;
        if(coor['cannon'] == 1) this._cannons.add(coor);
      }
    }
    
    
  }
negative.code:  * Über [_rng] wird die nächste Bewegung festgelegt 
   */
  abstract class Ship {
    Random _rng = new Random();
  
    SpaceInvaderModel _model;
  
    List<Map<String, int>> _parts = [];
    List<Map<String, int>> _cannons = [];
  
    Map<String, int> _leftMost;
    Map<String, int> _rightMost;
  
    int _hitpoints;
  
    /**
     * Konstruktor
     */
    Ship(SpaceInvaderModel model, List<Map<String, int>> parts, int hitpoints) {
      this._model = model;
      this._parts = parts;
      this._hitpoints = hitpoints;
  