Title: Funktionale Actor-Pipeline

### Abschluss: Eine funktionale Actor-Pipeline

Eine Pipeline verbindet kleine, klar benannte Operationen:

> alle Actors → **filter:** einsammelbare Münzen → **map:** Münzwerte →
> **reduce:** Gesamtpunktzahl

Auch in einem objektorientierten miniworlds-Spiel kann die Regellogik so
funktional bleiben. Die grafischen Actor-Objekte liefern Daten; reine
Funktionen entscheiden und berechnen das Ergebnis.

import miniworlds

# In einem echten Spiel könnten die Daten aus Coin-Actors stammen.
coin_daten = [
{"value": 10, "collected": False},
{"value": 25, "collected": True},

def actor_daten(actor):
"kind": actor.kind,
"value": actor.value,
"collected": actor.collected,

`actor_daten` bildet veränderliche Spielobjekte auf einfache Daten ab. Die
anschließende Pipeline kann unabhängig von Grafik und Ereignisschleife getestet
werden.

Implementiere `ist_offene_muenze(actor)`, `muenzenwert(actor)` und
`addiere_punkte(gesamt, wert)`. Jeder Datensatz ist ein Dictionary mit `kind`,
`value` und `collected`. Der vorgegebene Code verwendet deine Funktionen mit
`filter`, `map` und `reduce`. Gezählt werden nur Münzen, die noch nicht
eingesammelt wurden. Die Eingabeliste und ihre Dictionaries dürfen nicht
verändert werden.

from functools import reduce

def ist_offene_muenze(actor):
pass

def muenzenwert(actor):
pass

def addiere_punkte(gesamt, wert):
pass

actors = []
for _ in range(int(input())):
kind, value, collected = input().split()
"kind": kind,
"value": int(value),
"collected": collected == "ja"
kopie = [dict(actor) for actor in actors]
offene = filter(ist_offene_muenze, actors)
werte = map(muenzenwert, offene)
print(reduce(addiere_punkte, werte, 0))
print(actors == kopie)

coin 10 nein

enemy 100 nein

coin 25 ja

coin 5 nein

enemy 8 nein

coin 20 ja

coin 30 nein

decoration 50 nein