Add sheet3

https://www.youtube.com/watch?v=Z0GFRcFm-aY #election #murica

aufgaben/sheet3/task2/README.md

@@ -0,0 +1,163 @@
+Aufgabe 3.2: Pokemon
+====================
+
+In dieser Aufgabe soll ein kleines, Terminal-basiertes Pokemon-Spiel
+programmiert werden.
+Dieses Spiel werden wir in den nächsten Übungszetteln stetig erweitern.
+
+Um direkt mal etwas zu zeigen: *In etwa* so wird das Ergebnis dieser Aufgabe
+aussehen:
+
+```
+Player Red, please choose a Pokemon (or type '?' to get a complete list)
+?
+#001 Bulbasaur
+#002 Ivysaur
+#003 Venusaur
+#004 Charmander
+#005 Charmeleon
+#006 Charizard
+#007 Squirtle
+#008 Wartortle
+#009 Blastoise
+Player Red, please choose a Pokemon (or type '?' to get a complete list)
+Charmander
+Player Blue, please choose a Pokemon (or type '?' to get a complete list)
+Wartortle
+>>>>> Status: Charmander has 18 HP, Wartortle has 20 HP
+>>>>> Charmander is about to attack! Which move shall it execute?
+    0: Tackle
+    !!! Please give me the attack ID:
+0
+>>>>> Charmander uses Tackle! (Wartortle has 15 HP left)
+Wartortle is about to attack! Which move shall it execute?
+    0: Tackle
+    1: Water Gun
+    !!! Please give me the attack ID:
+1
+>>>>> Wartortle uses Water Gun! (Charmander has 7 HP left)
+>>>>> Status: Charmander has 7 HP, Wartortle has 15 HP
+Charmander is about to attack! Which move shall it execute?
+    0: Tackle
+    !!! Please give me the attack ID:
+0
+>>>>> Charmander uses Tackle! (Wartortle has 10 HP left)
+Wartortle is about to attack! Which move shall it execute?
+    0: Tackle
+    1: Water Gun
+    !!! Please give me the attack ID:
+0
+>>>>> Wartortle uses Tackle! (Charmander has 1 HP left)
+>>>>> Status: Charmander has 1 HP, Wartortle has 10 HP
+Charmander is about to attack! Which move shall it execute?
+    0: Tackle
+    !!! Please give me the attack ID:
+0
+>>>>> Charmander uses Tackle! (Wartortle has 5 HP left)
+Wartortle is about to attack! Which move shall it execute?
+    0: Tackle
+    1: Water Gun
+    !!! Please give me the attack ID:
+1
+>>>>> Wartortle uses Water Gun! (Charmander has 0 HP left)
+>>>>> Charmander fainted!
+```
+
+
+## Umfang und Art der Aufgabe
+
+In dieser Aufgabe wird bereits recht viel Code bereitgestellt und insgesamt
+wird die Lösung eher lang. Derzeit ist der komplette Code noch in einer Datei;
+das wird sich aber in der nächsten Woche ändern, wenn wir Module kennenlernen.
+
+Trotzdem soll diese Aufgabe schulen, sich in Rust-Code zurechtzufinden. Falls
+einige Sachen unklar sein sollten, zögert nicht, auf Piazza zu fragen! Viele
+gute Fragen auf Piazza helfen auch den anderen.
+
+Außerdem geht es in dieser Aufgabe natürlich um Pokemon. Ich habe versucht,
+alles so zu formulieren, dass es auch Menschen verstehen, die nie etwas mit
+Pokemon am Hut hatten. Falls mir das irgendwo nicht gelungen ist, sagt mir
+bitte Bescheid oder fragt direkt auf Piazza. "Pokemon" stand nämlich nicht als
+Voraussetzung in der Kursbeschreibung :P
+
+Aber grob beschrieben: In Pokemon gibt es komische Tiere/Monster, die "Pokemon"
+genannt werden. Diese Pokemon können von Menschen gefangen werden, meist um
+damit gegen andere "Pokemon-Trainer" zu kämpfen. Es gibt unterschiedliche
+Pokemon und unterschiedliche Attacken.
+
+In der bereitgestellten Datei gibt es bereits diversen Code. Davon besteht ein
+größerer Teil nur aus Konstanten. Das sind einfach Daten über Pokemon und
+Attacken, die nicht weiter verstanden werden müssen. Wichtig ist aber, dass
+all diese Daten direkt in der Executable gespeichert sind und daher immer die
+`'static` Lifetime haben.
+
+
+## a) Pokemon wählen lassen
+
+In diesem Teil geht es darum, die beiden Spieler zu fragen, welches Pokemon sie
+benutzen möchten. Dazu sollt ihr ein paar Funktionen erstellen:
+
+- `print_pokemon_list`: Druckt eine Liste aller verfügbaren Pokemon (in der
+  `POKEDEX` Konstante gespeichert) auf dem Terminal.
+- `find_pokemon_by_name`: Bekommt einen Namen und sucht nach einem PokemonModel
+  mit diesem Namen im `POKEDEX`. Gibt das PokemonModel zurück, oder `None`,
+  wenn der Name nicht gefunden wurde. Die Suche darf gerne in O(n) sein.
+- `choose_pokemon`: Fordert den Spieler auf, den Namen eines Pokemon einzugeben.
+  Bietet außerdem an, alle Pokemon aufzulisten, wenn der Spieler '?' eingibt.
+  Diese Funktion liefert dann ein PokemonModel zurück (falls der Spieler
+  einen ungültigen Namen eingibt, erneut auffordern, einen richtigen Namen
+  einzugeben). Hierfür ist die Funktion `read_string()` nützlich!
+
+Wenn diese Funktionen funktionieren, soll `choose_pokemon()` in der `main()`-
+Funktion aufgerufen werden, sodass beide Spieler ein Pokemon wählen können.
+
+
+
+## b) `Pokemon` Typ implementieren
+
+Bis jetzt gibt es nur einen Typ `PokemonModel`, der globale Eigenschaften von
+einer Pokemon-Art speichert (wie z.B.: "Pferde haben vier Beine").
+Allerdings brauchen wir noch einen Typ, der eine Instanz eines Pokemon
+darstellt (wie z.B. "dieses Tier ist ein Pferd und hat braunes Fell").
+Dazu soll ein neuer Typ `Pokemon` angelegt werden.
+
+Dieser Typ speichert sich folgende Daten:
+
+- Zu welcher Pokemon-Art er gehört (Referenz auf ein `PokemonModel`; wichtig:
+  alle PokemonModels haben eine `'static` Lifetime).
+- Die derzeitigen "stats" (Typ `Stats`), also z.B. auch die HP
+- Das derzeitige Level (mögliche Level: 1 bis 100)
+
+Der Typ soll folgende Funktionen und Methoden besitzen:
+
+- Konstruktor-Funktion `with_level`: Gegeben wird ein PokemonModel und ein
+  Level, eine gültige `Pokemon`-Instanz soll zurückgegeben werden. Hinweis:
+  Nützlich ist die Funktoin `Stats::at_level()`.
+- Getter-Methoden (in Rust verzichtet man auf `get_`, also nicht `get_foo`,
+  sondern oft nur `foo`):
+  - `stats()`
+  - `model()`
+  - `name() `
+  - `level()`
+- `is_alive()`
+- `endure_attack()`: Bekommt eine Referenz auf ein anderes Pokemon und auf
+  eine Attacke. Abhängig davon werden die HP von dem jetzigen Pokemon
+  angepasst. Ihr braucht die Funktion `attack_damage()` dafür.
+
+
+## c) Kampfsystem
+
+Zuletzt müssen wir nur noch das eigentliche Kampfsystem bauen. Dazu sollen
+abwechselnd beide Spieler aufgefordert werden, eine Attacke auszusuchen.
+Diese Attacke wird dann vom Pokemon ausgeführt und so das andere Pokemon
+verletzt. Die ungefähren Anforderungen:
+
+- Beide Spieler werden abwechselnd gefragt
+- Es werden die verfügbaren Attacken aufgelistet
+- Die gewählte Attacke wird ausgeführt
+- Der Status beider Pokemon wird regelmäßig angezeigt
+- Wenn ein Pokemon stirbt, soll sich das Programm beenden
+
+Euer Programm muss nicht genau so aussehen, wie oben im Beispiel gezeigt.
+
+Bonusaufgabe: Zuerst darf das Pokemon mit dem höheren `speed` Wert angreifen.

aufgaben/sheet3/task2/poki.rs

@@ -0,0 +1,446 @@
+//! Task 3.2: Pokemon
+
+fn main() {}
+
+
+
+/// Describes an attack with all its properties. This type is similar to
+/// `PokemonModel`, as there are finite many, immutable instances of this type
+/// in a database. This is not a type whose instances change over time.
+#[derive(Debug, Clone, Copy)]
+struct Attack {
+    category: AttackCategory,
+    name: &'static str,
+    /// Base power of the move. The actual inflicted damage is calculated with
+    /// a formula using the move's power and a few other parameters.
+    base_power: u8,
+    type_: Type,
+}
+
+/// Category of an attack.
+///
+/// Note: currently, the category 'status' is missing.
+#[derive(Debug, Clone, Copy)]
+enum AttackCategory {
+    /// Attacks with body contact, like "Tackle" or "Bite"
+    Physical,
+    /// Attacks without body contact, like "Bubble Beam" or "Thunderbolt"
+    Special,
+}
+
+/// Describes how effective an attack of one type is on a Pokemon of another
+/// type.
+///
+/// Note that a Pokemon can have two types. In order to determine the
+/// effectiveness, the multipliers of the effectivenesses on both types
+/// are multiplied. As such, there can be 0.25 and 4.0 multipliers!
+#[derive(Debug, Clone, Copy)]
+enum TypeEffectiveness {
+    NotEffective,
+    NotVeryEffective,
+    Normal,
+    SuperEffective,
+}
+
+impl TypeEffectiveness {
+    /// Returns the type effectiveness of an attack from one attacker type
+    /// on one defender type.
+    fn of_attack(attacker: Type, defender: Type) -> Self {
+        use Type::*;
+        use TypeEffectiveness as Te;
+
+        // TODO: complete this
+        match (attacker, defender) {
+            (Fire, Water) => Te::NotVeryEffective,
+            (Fire, Grass) => Te::SuperEffective,
+            (Water, Fire) => Te::SuperEffective,
+            (Water, Grass) => Te::NotVeryEffective,
+            (Grass, Fire) => Te::NotVeryEffective,
+            (Grass, Water) => Te::SuperEffective,
+            _ => Te::Normal,
+        }
+    }
+
+    /// Returns the corresponding multiplier for the damage formula.
+    fn multiplier(&self) -> f64 {
+        match *self {
+            TypeEffectiveness::NotEffective => 0.0,
+            TypeEffectiveness::NotVeryEffective => 0.5,
+            TypeEffectiveness::Normal => 1.0,
+            TypeEffectiveness::SuperEffective => 2.0,
+        }
+    }
+}
+
+
+/// Types (sometimes called "elements") of the Pokemon universe. Each
+/// attack-move has exactly one type, Pokemons can have one or two types.
+#[derive(Debug, Clone, Copy)]
+#[allow(dead_code)]
+enum Type {
+    Normal,
+    Fire,
+    Fighting,
+    Water,
+    Flying,
+    Grass,
+    Poison,
+    Electric,
+    Ground,
+    Psychic,
+    Rock,
+    Ice,
+    Bug,
+    Dragon,
+    Ghost,
+    Dark,
+    Steel,
+    Fairy,
+}
+
+/// Describes the type of a Pokemon. Pokemon can have one or two types.
+#[derive(Debug, Clone, Copy)]
+enum PokemonType {
+    One(Type),
+    Two(Type, Type),
+}
+
+/// Describes a kind of Pokemon, e.g. "Pikachu".
+///
+/// This is different than an actual, living Pokemon. This struct just
+/// describes properties that are the same for every creature of this
+/// Pokemon kind.
+#[derive(Debug, Clone, Copy)]
+struct PokemonModel {
+    /// Name of the Pokemon
+    name: &'static str,
+    /// ID in the international Pokedex
+    id: u16,
+    type_: PokemonType,
+    base_stats: Stats,
+    /// This is different from the real Pokemon games: attacks are not part
+    /// of the Pokemon model, but of the Pokemon itself (as they change over
+    /// time). A pokemon just has an abstract learnset of potential attacks.
+    /// But this is easier for now.
+    attacks: &'static [&'static Attack]
+}
+
+/// Describes the basic stats of a Pokemon.
+///
+/// Each living Pokemon has an actual stat value, but each Pokemon kind also
+/// has so called "base stats". These base stats are used to calculate the
+/// actual stats, whose depend on the Pokemon's current level. Stronger Pokemon
+/// have higher base stats.
+#[derive(Debug, Clone, Copy)]
+struct Stats {
+    /// Health points
+    hp: u16,
+    /// Speed, sometimes called initiative (INIT)
+    speed: u16,
+    /// Strength of physical attacks (like "Tackle")
+    attack: u16,
+    /// Strength of special attacks (like "Bubble Beam")
+    special_attack: u16,
+    /// Defense power against physical attacks (like "Tackle")
+    defense: u16,
+    /// Defense power against special attacks (like "Bubble Beam")
+    special_defense: u16,
+}
+
+impl Stats {
+    /// Given the base stats and a level, this function returns the actual
+    /// stats for that level.
+    ///
+    /// This function doesn't implement the correct formula used by Pokemon
+    /// games. It is a simplified version of the original formula for now: we
+    /// ignore IVs, EVs and the Pokemon's nature). The complete formula can be
+    /// found [here (HP)][1] and [here (other stats)][2].
+    ///
+    /// [1]: http://bulbapedia.bulbagarden.net/wiki/File:HPStatCalcGen34.png
+    /// [2]: http://bulbapedia.bulbagarden.net/wiki/File:OtherStatCalcGen34.png
+    fn at_level(base: Self, level: u8) -> Self {
+        /// The formula is the same for all stats != hp
+        fn stat_formula(base: u16, level: u8) -> u16 {
+            ((base as f64 * level as f64) / 50.0 + 5.0) as u16
+        }
+
+        let hp = (
+            (base.hp as f64 * level as f64) / 50.0
+                + level as f64
+                + 10.0
+        ) as u16;
+
+        Stats {
+            hp: hp,
+            speed: stat_formula(base.speed, level),
+            attack: stat_formula(base.attack, level),
+            special_attack: stat_formula(base.special_attack, level),
+            defense: stat_formula(base.defense, level),
+            special_defense: stat_formula(base.special_defense, level),
+        }
+    }
+}
+
+// ===========================================================================
+// ===========================================================================
+// ===========================================================================
+// Formulas to calculate stuff
+// ===========================================================================
+// ===========================================================================
+// ===========================================================================
+
+/// Calculates the damage of an attack. We don't use the exact formula, but
+/// a simplified version of it. In particular, we simplified the "Modifier"
+/// term quite a bit. The correct and complete formula can be found [here][1].
+///
+/// [1]: http://bulbapedia.bulbagarden.net/wiki/Damage#Damage_formula
+// fn attack_damage(attacker: &Pokemon, defender: &Pokemon, attack: Attack) -> u16 {
+//     // Depending on the attack category, get the correct stats
+//     let (attack_mod, defense_mod) = match attack.category {
+//         AttackCategory::Physical => {
+//             (attacker.stats().attack, defender.stats().defense)
+//         }
+//         AttackCategory::Special => {
+//             (attacker.stats().special_attack, defender.stats().special_defense)
+//         }
+//     };
+
+//     // Cast everything to f64 to reduce noise in actual formula
+//     let (attack_mod, defense_mod) = (attack_mod as f64, defense_mod as f64);
+//     let base_power = attack.base_power as f64;
+//     let attacker_level = attacker.level() as f64;
+
+//     // The modifier only depends on the type effectiveness (in our simplified
+//     // version!).
+//     let modifier = match defender.model().type_ {
+//         PokemonType::One(ty) => {
+//             TypeEffectiveness::of_attack(attack.type_, ty).multiplier()
+//         }
+//         PokemonType::Two(ty_a, ty_b) => {
+//             TypeEffectiveness::of_attack(attack.type_, ty_a).multiplier()
+//                 * TypeEffectiveness::of_attack(attack.type_, ty_b).multiplier()
+//         }
+//     };
+
+//     // With every parameter prepared above, here is the formula
+//     (
+//         (
+//             ((2.0 * attacker_level + 10.0) / 250.0)
+//                 * (attack_mod / defense_mod)
+//                 * base_power
+//                 + 2.0
+//         ) * modifier
+//     ) as u16
+// }
+
+// ===========================================================================
+// ===========================================================================
+// ===========================================================================
+// This is just constant data!
+// ===========================================================================
+// ===========================================================================
+// ===========================================================================
+
+/// The Pokemon database!
+///
+/// Apart from the "attacks" field, all values are correct.
+const POKEDEX: &'static [PokemonModel] = &[
+    PokemonModel {
+        name: "Bulbasaur",
+        id: 001,
+        type_: PokemonType::Two(Type::Poison, Type::Grass),
+        base_stats: Stats {
+            hp: 45,
+            attack: 49,
+            defense: 49,
+            special_attack: 65,
+            special_defense: 65,
+            speed: 45,
+        },
+        attacks: &[TACKLE],
+    },
+    PokemonModel {
+        name: "Ivysaur",
+        id: 002,
+        type_: PokemonType::Two(Type::Poison, Type::Grass),
+        base_stats: Stats {
+            hp: 60,
+            attack: 62,
+            defense: 63,
+            special_attack: 80,
+            special_defense: 80,
+            speed: 60,
+        },
+        attacks: &[TACKLE, VINE_WHIP],
+    },
+    PokemonModel {
+        name: "Venusaur",
+        id: 003,
+        type_: PokemonType::Two(Type::Poison, Type::Grass),
+        base_stats: Stats {
+            hp: 80,
+            attack: 82,
+            defense: 83,
+            special_attack: 100,
+            special_defense: 100,
+            speed: 80,
+        },
+        attacks: &[TACKLE, VINE_WHIP],
+    },
+    PokemonModel {
+        name: "Charmander",
+        id: 004,
+        type_: PokemonType::One(Type::Fire),
+        base_stats: Stats {
+            hp: 39,
+            attack: 52,
+            defense: 43,
+            special_attack: 60,
+            special_defense: 50,
+            speed: 65,
+        },
+        attacks: &[TACKLE],
+    },
+    PokemonModel {
+        name: "Charmeleon",
+        id: 005,
+        type_: PokemonType::One(Type::Fire),
+        base_stats: Stats {
+            hp: 58,
+            attack: 64,
+            defense: 58,
+            special_attack: 80,
+            special_defense: 65,
+            speed: 80,
+        },
+        attacks: &[TACKLE, EMBER],
+    },
+    PokemonModel {
+        name: "Charizard",
+        id: 006,
+        type_: PokemonType::Two(Type::Fire, Type::Flying),
+        base_stats: Stats {
+            hp: 78,
+            attack: 84,
+            defense: 78,
+            special_attack: 109,
+            special_defense: 85,
+            speed: 100,
+        },
+        attacks: &[TACKLE, EMBER],
+    },
+    PokemonModel {
+        name: "Squirtle",
+        id: 007,
+        type_: PokemonType::One(Type::Water),
+        base_stats: Stats {
+            hp: 44,
+            attack: 48,
+            defense: 65,
+            special_attack: 50,
+            special_defense: 64,
+            speed: 43,
+        },
+        attacks: &[TACKLE],
+    },
+    PokemonModel {
+        name: "Wartortle",
+        id: 008,
+        type_: PokemonType::One(Type::Water),
+        base_stats: Stats {
+            hp: 59,
+            attack: 63,
+            defense: 80,
+            special_attack: 65,
+            special_defense: 80,
+            speed: 58,
+        },
+        attacks: &[TACKLE, WATER_GUN],
+    },
+    PokemonModel {
+        name: "Blastoise",
+        id: 009,
+        type_: PokemonType::One(Type::Water),
+        base_stats: Stats {
+            hp: 79,
+            attack: 83,
+            defense: 100,
+            special_attack: 85,
+            special_defense: 105,
+            speed: 78,
+        },
+        attacks: &[TACKLE, WATER_GUN],
+    },
+];
+
+/// List of all attacks.
+///
+/// Of course, these are not all attacks. We will probably provide a much
+/// bigger database with the next sheet.
+const ATTACK_DB: &'static [Attack] = &[
+    Attack {
+        category: AttackCategory::Physical,
+        name: "Tackle",
+        base_power: 50,
+        type_: Type::Normal,
+    },
+    Attack {
+        category: AttackCategory::Special,
+        name: "Vine Whip",
+        base_power: 45,
+        type_: Type::Grass,
+    },
+    Attack {
+        category: AttackCategory::Special,
+        name: "Ember",
+        base_power: 40,
+        type_: Type::Fire,
+    },
+    Attack {
+        category: AttackCategory::Special,
+        name: "Water Gun",
+        base_power: 40,
+        type_: Type::Water,
+    },
+];
+
+// These are just some easy names to be more expressive in the Pokedex.
+const TACKLE: &'static Attack = &ATTACK_DB[0];
+const VINE_WHIP: &'static Attack = &ATTACK_DB[1];
+const EMBER: &'static Attack = &ATTACK_DB[2];
+const WATER_GUN: &'static Attack = &ATTACK_DB[3];
+
+
+
+
+// ===========================================================================
+// ===========================================================================
+// ===========================================================================
+// Helper functions (you don't need to understand how they work yet)
+// ===========================================================================
+// ===========================================================================
+// ===========================================================================
+
+/// Reads a string from the terminal/user.
+fn read_string() -> String {
+    let mut buffer = String::new();
+    std::io::stdin()
+        .read_line(&mut buffer)
+        .expect("something went horribly wrong...");
+
+    // Discard trailing newline
+    let new_len = buffer.trim_right().len();
+    buffer.truncate(new_len);
+
+    buffer
+}
+
+/// Reads a valid `usize` integer from the terminal/user.
+fn read_usize() -> usize {
+    loop {
+        match read_string().parse() {
+            Ok(res) => return res,
+            Err(_) => println!("That was not an integer! Please try again!"),
+        }
+    }
+}