Erste Schritte mit Rust

Vor ein paar Tagen wollte ich die Programmiersprache Rust ausprobieren. Bei Rust handelt es sich um eine Sprache, welche syntaktisch stark an C angelehnt ist und besonderes Augenmerk auf Sicherheit legt. Die erste Frage, die sich mir stellte, ist, ob es für Rust, eine vernünftige IDE-Unterstützung existiert. Fündig geworden bin ich bei IntelliJ IDEA, welches nach Installation des Rust-Plugins zur Programmierung in der Sprache genutzt werden kann. Debugging von Rust-Programmen wird aus technischen Gründen nur in der JetBrains IDE CLion unterstützt, sodass hier einige Abstriche gemacht werden müssen. Neben der Rust-Integration für IntelliJ IDEA gibt es ebenfalls ein Plugin für Visual Studio Code, welches hier allerdings nicht weiter behandelt werden soll.

Mit dem passenden Plugin beherrscht IntelliJ IDEA Rust.

Neben der eigentlichen IDE wird Rust benötigt. Dieses kann über die offizielle Seite der Sprache bezogen werden. Nach der Installation kann in der IDE ein erstes Projekt angelegt werden. Anschließend findet sich in einem Ordner mit dem Namen src eine Datei mit dem Namen main.rs:

fn main() {
    println!("Hello, world!");
}

In dieser Datei findet sich ein minimales Hello world-Programm. Das Ausrufezeichen hinter dem println zeigt unter Rust an, das es sich um ein Makro handelt. Damit können Methoden und Makros einfach auseinander gehalten werden. Da ich Hello world-Programme immer etwas sinnfrei finde was das Lernen einer neuen Programmiersprache angeht, wollte ich für den ersten Versuch das Spiel Zahlenraten programmieren. Ziel des Spieles ist es eine Zahl zwischen 0 und 1000 zu erraten, welche der Rechner sich ausgedacht hat. Dazu muss im ersten Schritt eine Variable definiert werden, in welcher die zufällige Zahl gespeichert wird. Grundsätzlich sieht eine Variablendefinition und Deklaration unter Rust wie folgt aus:

let name: Typ = Wert;

Variablen in Rust sind immer Konstanten, wenn sie nicht explizit als veränderlich angegeben werden. Möglich ist dies mit dem Schlüsselwort mut:

let mut name: Typ = Wert;

Die Benennung von Variablen und anderen Elementen folgt in Rust einem bestimmten Schema. So werden Variablen snake_case benannt. Neben der Definition der Variable muss eine zufällige Zahl zwischen 0 und 1000 generiert werden. Dazu dient ein Zufallsgenerator, welcher über ein use eingebunden werden muss:

use rand::Rng;

Anschließend kann die Variable definiert und deklariert werden:

let number: u32 = rand::thread_rng().gen_range(0, 1000);

In diesem Fall wird ein vorzeichenloser Integer mit 32 Bit Breite als Datentyp definiert. Wird nun versucht das Rust-Programm zu kompilieren, so wird die Fehlermeldung:

error[E0432]: unresolved import `rand`
 --> src\main.rs:1:5
  |
1 | use rand::Rng;
  |     ^^^^ use of undeclared type or module `rand`

error[E0433]: failed to resolve: use of undeclared type or module `rand`
 --> src\main.rs:4:23
  |
4 |     let number: u32 = rand::thread_rng().gen_range(0, 1000);
  |                       ^^^^ use of undeclared type or module `rand`

error: aborting due to 2 previous errors

auftauchen. Grund hierfür ist, dass das genutzte Paket über den Paketmanager von Rust bezogen werden muss. Pakete werden über den Paketmanager Cargo bezogen. Die entsprechenden Pakete des offiziellen Repositorys sind unter crates.io zu finden. In der Datei Cargo.toml müssen die entsprechenden Abhängigkeiten eingebunden werden:

[dependencies]
rand = "0.7.3"
text_io = "0.1.8"

Neben dem Pseudozufallszahlengenerator, wurde gleich noch das Paket text_io eingebunden, welches später für die Eingabe von Text benötigt wird. Dieses Paket stellt hierbei das Makro read zur Verfügung, mit dessen Hilfe eine Eingabe realisiert werden kann:

let user_number: u32 = read!();

Damit sind die Grundlagen für das Spiel Zahlenraten gelegt und der Rest des Quellcodes ergibt praktisch sich von selbst:

use rand::Rng;
use text_io::read;

fn main() {

    let number: u32 = rand::thread_rng().gen_range(0, 1000);

    let mut running = true;

    println!("Ich habe mir eine Zahl zwischen 0 und 1000 ausgedacht.");

    while running {

        println!("Dein Vorschlag: ");
        let user_number: u32 = read!();

        if number > user_number {
            println!("Meine Zahl ist größer.");
        } else if number < user_number {
            println!("Meine Zahl ist kleiner.");
        } else {
            running = false;
        }
    }

    println!("Du hast die Zahl erraten. Es war die {}.", number);
}

Hervorzuheben ist, das unter Rust in if-Statements und Schleifen keine Klammern benötigt werden. Werden diese trotzdem genutzt, so warnt der Compiler entsprechend und bittet die überflüssigen Klammern zu entfernen.

Neben der entsprechenden Dokumentation auf der offiziellen Seite empfiehlt sich das Rust Cookbook als Quelle für die ersten Schritte unter Rust. Wer Rust einfach mal im Browser ausprobieren möchte, kann hierfür den Rust Playground nutzen.

Evoli in Pokémon Go selektiv entwickeln

Das Pokémon Evoli kann sich in unterschiedlichste Pokémon weiterentwickeln. In der ersten Generation waren dies Aquana, Blitza, Flamara. Mittlerweile sind noch Folipurba, Glaziola, Nachtara und Psiana hinzugekommen. Wird ein Evoli in Pokémon Go entwickelt, so wird es sich zufällig entwickeln.

Ein Evoli in der Stadt

Mit einem kleinen Trick lässt sich die Entwicklungsform eines Evoli allerdings steuern. Dazu muss dem Pokémon vor der Entwicklung ein bestimmter Name gegeben werden:

Rainer -> Aquana 	
Sparky -> Blitza 	
Pyro   -> Flamara 	
Linnea -> Folipurba 	
Rea    -> Glaziola
Tamao  -> Nachtara 	
Sakura -> Psiana

Wurde der entsprechende Name vor der Entwicklung vergeben, so entwickelt sich das Evoli in die entsprechende Form. Pro Form lässt sich der Trick exakt einmal anwenden.

The Swords of Ditto

In den letzten Tagen habe ich viel Zeit damit verbracht das Spiel The Swords of Ditto zu spielen. Das Spiel, welches ursprünglich Mitte 2018 erschien, ist mittlerweile auch für iOS erhältlich.

‎The Swords of Ditto
Preis: 6,99 €

In dem Spiel geht es um einen Protagonisten, welcher zum Schwert von Ditto wird und somit die fiktive Insel Ditto von der Hexe Mormo befreien muss. Allerdings stirbt er gleich beim ersten Versuch und so vergehen wieder hundert Jahre bis ein neuer Protagonist zum Schwert von Ditto wird. Das Spiel glänzt unter anderem durch seinen Humor, welcher das Spiel und den Helden auf die Schippe nimmt. Jedes Mal, wenn der Held das Zeitliche segnet, vergehen wieder einhundert Jahre und die Welt in Ditto verfällt zusehens.

The Swords of Ditto unter iOS

Das Genre des Spieles bewegt sich zwischen einem Action-RPG mit Anleihen im Roguelike, welche vor allem in den unterschiedlichen Verliesen zum Tragen kommen. Unter iOS lässt sich das Spiel auch mit einem externen Controller spielen. Die offizielle Seite des Spieles ist unter theswordsofditto.com zu finden.

Was bringt Entwicklung bei Pokémon Go?

In Pokémon Go können Pokémon, wie in vielen Spielen der Reihe, entwickelt werden. Die Frage, die sich stellt, ist, ob sich die Entwicklung eines Pokémon lohnt. Die Antwort darauf ist relativ einfach: im Prinzip ja. Allerdings kommt es auf einige Feinheiten an. Pokémon können im Spiel auf zwei Arten trainiert werden, über Power-Ups und die Entwicklung.

Die Entwicklung des Pokémon erhöht die WP

Bei der Entwicklung wird die WP-Zahl um ein gutes Stück angehoben, bei einem Power-up sind es meist um die 50 Punkte um die sich der WP-Wert erhöht. Die Reihenfolge, also erst Power-Ups und dann die Entwicklung oder umgekehrt spielt hierbei keine Rolle. Allerdings sollte mit der Entwicklung gewartet werden bis ein bestimmtes Trainerlevel erreicht ist. Ab Level 30 kann bedenkenlos entwickelt werden. Daneben sollte bei der Entwicklung darauf geachtet werden, das am besten nur Pokèmon mit hohen IV-Werten entwickelt werden.

Factorio in HD

Factorio ist ein Spiel, in welchem der Protagonist auf einem Planeten abstürzt und anschließend versucht wieder zu entkommen, indem er eine Rakete baut. Dazu müssen komplexe Fabrikanlagen gebaut werden und diese miteinander verbunden werden.

Factorio
Preis: 25 €

In den bisherigen Versionen wirkte die Grafik eher altgebacken, aber dies hat sich mit der eben erschienenen Version 0.17 geändert. In dieser neuen Version wurde unter anderem die Grafik des Spieles aufpoliert.

Factorio glänzt nun mit neuer Grafik

Daneben gab es viele weitere, kleinere und größere, Änderungen. So wurde die komplette Oberfläche überarbeitet, der Forschungsbaum angepasst, der Mapeditor umgeschrieben, sodass dieser nun direkt im Spiel genutzt werden kann. Auch die Feinde wurden komplett überarbeitet. Unter der Haube wurde unter anderem das komplette Rendering-Backend neugeschrieben. Alles in allem ist mit der neuen Factorio-Version ein großer Wurf gelungen.