# Asteroids als MVC



## Martino (19. Nov 2014)

Hallo, ich hab ein kleines Anliegen unabhängig von der Programmiersprache.

Ich bin derzeit dabeii das klassische Asteroids als MVC umzusetzen.
Also ein Model, dass die Daten und die Zugriffslogik bzw. Manipulation dieser Daten steuert.
Ein Controller, der die Nutzereingaben in "Geschäftslogik" transferiert und das model entsprechend ansteuert bzw. die view. Über den controller würde ich auch den game-loop auslösen.
Und die View, die alles rendert.

Ich denke, dass Asteroids sich nicht so wirklich anbietet für das MVC Design. 
Problematisch finde ich die strikte Trennung zwischen Model und View, bwz. z.B. der Positionsdaten der Spielobjekte. Diese werden ja in jedem game-tick manipuliert und müssen entsprechend neu angezeigt werden in der View.
In meiner View habe ich meine Sprite-Objects, die aber natürlich keinen linkage haben zu ihrem Datenobjekt, d.h. in jedem gameloop müssen die Sprites neu erstellt werden und positioniert werden. 
Ich kann sie natürlich poolen, damit sie nicht jedesmal neu erzeugt werden müssen.
Aber praktischer wäre es natürlich schon, wenn ein Sprite-Object auch entsprechende Model-Daten kapseln würde und z.B. ihre Position über ein update-funktion selbst berechnet. Man hätte dann natürlich nicht mehr die Trennung zwischen View und Model.

Was sind eure Gedanken dazu?


----------



## JavaMeister (19. Nov 2014)

MVC wird überbewertet.


----------



## Martino (20. Nov 2014)

Kommt auf die Anforderungen Deiner Software an.
Es erleichert in grossen Projekten die Zusammenarbeit und Einarbeitung in den Code.
Bei framebasierten Spielen, in denen Spiellogik mehrmals pro Sekunde durchgeführt werden muss, halte ich es auch eher für schwierig.
Bei Spielen ( software ), die durch Nutzerinteraktion getrieben sind, fühlt es sich sinnvoller an.


----------



## Ruzmanz (20. Nov 2014)

Ich würde das Model sperarieren, obwohl es ein bisschen mehr Aufwand bedeutet. Dem MVC-Pattern würde ich wahrscheinlich auch nicht 100% folgen ... Ein einfaches Beispiel:


```
for(Sprite sprite: sprites) {
  sprite.manipulate();
  sprite.update();
  render(g);
}

Dragon {
  DragonModel model;
  Image image;

  manipulate() {
    model.setPositionX(745);
    model.setPositionY(20);
  }

  update() {
    image.setX(model.getPositionX());
    image.setY(model.getPositionY());
  }

  render(Graphics g) {
    g.draw(image);
  }
}
```

Du aktualisiert dein Model mit "manipulate()" und / oder sonstigen Methoden. Dann überträgst du die Werte 1:1 in deine "View". Anschließend zeichnest du dein Sprite. Vorteile?

Zuschauer- /Replaymodus:

Spieler:

```
for(Sprite sprite: sprites) {
  sprite.manipulate();
  send(DragonModel); // bzw. save(DragonModel)
  sprite.update();
  render(g);
}
```

Zuschauer:


```
receiveAndUpdateModels(); // bzw. loadAndUpdateModels();
for(Sprite sprite: sprites) {
  sprite.update();
  render(g);
}
```

KI-Player:

```
for(Sprite sprite: sprites) {
  sprite.manipulate();
  // no update;
  // no render;
}
```
Level Editor / Textdatei-Level:
Speichern:
"Asteroid,134,156,3"

Laden:

```
if(data.startsWith("Asteroid")) {
  model = new AsteroidModel()
  sprites.add(new Asteroid(model));
}

AsteroidModel() {
  AsteroidModel(String line) {
    String data = line.split(",");
    posX = data[1];
    posY = data[2];
    category = data[3];
  }
}
```

Geht weiter mit Netzwerken, Datenanalyse, Implementierung in mehreren Programmiersprachen ... Mit den "reinen" Daten kann man viel anfangen. Es funktioniert auch ohne Trennung, dann musst du aber alle Informationen mühsam zusammensuchen.


----------

