anchor.diff:   * Ü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){
  +  Ship(SpaceInvaderModel model, List<Map<String, int>> parts, int hitpoints) {
       this._model = model;
       this._parts = parts;
       this._hitpoints = hitpoints;
  
positive.code:  * Besitzt neben [_leftMost] und [_rightMost] auch noch [_bottomMost] um festzustellen, ob das Spiel verloren wurde
   */
  class EnemyShip extends Ship {
    
    Map<String, int> _bottomMost;
    
    EnemyShip(SpaceInvaderModel model, List<Map<String, int>> parts, int hitpoints) : super(model, parts, hitpoints);
    
    void move(){ 
      switch(determineDirection()){
        case 'down':
          if(this._bottomMost['row'] == gamesize-1) { _model.setGameOver(); break; }
          else {
            for(Map coor in _parts){
              coor['row'] += 1;
              if(coor['row'] > this._bottomMost['row']) this._bottomMost = coor; 
            }
          }
          print("moved down");
          break;
        case 'left':
          if(this._leftMost['col'] == 0) break;
          else {
            for(Map coor in _parts){
              coor['col'] -= 1;
              if(coor['col'] < _leftMost['col']) this._leftMost = coor; 
            }
          print("moved left");
          }
          break;
        case 'right':
          if(this._rightMost['col'] == gamesize-1) break;
          else { 
            for(Map coor in _parts){
              coor['col'] += 1;
              if(coor['col'] > this._rightMost['col']) this._rightMost = coor; 
            }
          print("moved right");
          }
          break;
      }
      
      this.detectCollision();
  
    }
    
    determineDirection(){
      int dir = _rng.nextInt(12);
      
      if(dir<=5)                 return 'down';
      else if(dir>=6 && dir<=8)  return 'left';
      else if(dir>=9 && dir<=11) return 'right';
    }
    
    shoot() {
      for(Map<String, int> coor in _cannons) {
        int chance = _rng.nextInt(10);
        if(chance == 1)  this._model.spawnProjectile({'row': (coor['row']+1), 'col': coor['col'], 'dir': 1});
      }
    }
    
    reduceHitpointsBy(int damage){
      this._hitpoints -= damage;
      
      if(this._hitpoints <= 0) {
        this._model.removeEnemy(this);
        this._model.addScore(this._hitpoints);
        print('Ship is destroyed!');
      }
    }
    
    setup(){
      this._leftMost = _parts[0];
      this._rightMost = _parts[0];
      this._bottomMost = _parts[0];
      
      for(Map coor in _parts){
        if(coor['row'] > this._bottomMost['row']) this._bottomMost = coor; 
        if(coor['col'] < this._leftMost['col']) this._leftMost = coor; 
        if(coor['col'] > this._rightMost['col']) this._rightMost = coor;
        if(coor['cannon'] == 1) this._cannons.add(coor);
      }
    }
    
  }
  
  /**
  
negative.code:   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() {
      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'])) {
            print('Hit by enemy! Reducing HP by 1');
            this.reduceHitpointsBy(1);
            this._model.removeProjectile(prj);
  