Hier ist eine Version, die von der obigen pexpect inspiriert ist.
Verwenden Sie zum Ausführen Python 3 und installieren Sie click (möglicherweise in einer virtuellen Umgebung). Suchen Sie dann in der Befehlszeile nach Hilfe:
$ python explore.py --help
Verwendung: explore.py [OPTIONEN]
Bereise deine Minecraft-Welt
Optionen:
-p, --player TEXT Setzt diesen Namen auf einen angemeldeten Minecraft-Spieler
-s, --start TEXT Startpunkt x: z
-r, --radius INTEGER Breite der Welt, die Sie generieren möchten
--help Diese Nachricht anzeigen und beenden.
Ab einem Punkt teleportiert es einen Spieler schrittweise in einer nach außen gerichteten Spirale, bis eine bestimmte Breite erreicht ist.
Der folgende Code setzt voraus, dass Ihre Welt in einem Docker-Image ausgeführt wird. Bearbeiten Sie die Funktion run_mc_command entsprechend Ihrem Hosting.
Es ist langsam: Das Erzeugen einer 1000x1000-Welt ist (1000/16) ^ 2 = 3906 Teleports mit jeweils mindestens einer halben Sekunde.
Hier ist der Code:
#! / usr / bin / python
aus dem Subprozess-Importlauf
Zählen Sie aus dem Importzyklus von itertools
Importklick
@ click.command ()
@ click.option ("- p", "--player",
help = "Setze einen Namen für einen angemeldeten Minecraft-Spieler")
@ click.option ("- s", "--start",
help = "Startpunkt x: z",
Standard = "0: 0")
@ click.option ("- r", "--radius",
help = "Breite der Welt, die generiert werden soll",
Standard = 5000)
def main (Spieler: str, Start: str, Radius):
"" Reisen Sie durch Ihre Minecraft-Welt "" "
start = start.split (":", 2)
parsed_start = float (Start [0]), float (Start [1])
click.echo ("Welt erkunden")
click.echo (f "Puppenspiel {Spieler! s}")
click.echo (f "Ausgehend von {parsed_start! s}")
click.echo (f "Bis zum Erreichen des Radius von {Radius! s} Metern (natürlich quadratisch)")
erkunden (Spieler, parsed_start, float (Radius))
def explore (Spieler: str, Start: Tupel, Breite: float, Schritt: float = 16) -> Keine:
"" "
Reisen Sie Ihre Minecaft-Welt
Argumente:
Spieler: Ein angemeldeter Spieler wird teleportiert. Dies ist der Spielername.
Start: Startkoordinate (x, z).
width: Breite des Quadrats, das Sie erkunden möchten.
Schritt: Länge der Sprünge. Der Standardwert ist 16 Minecraft-Blöcke.
"" "
run_mc_command (f "gamemode creative {player! s}")
für Position in walk_spiral (Start, Schritt):
run_mc_command (f "tp {player! s} {position [0]! s} 255 {position [1]! s}")
Entfernung = Position [0] - Start [0], Position [1] - Start [1]
wenn Abstand [0] > Breite:
Unterbrechung
def run_mc_command (Befehl: str) -> Keine:
"" "
Führen Sie einen Minecraft-Konsolenbefehl aus.
Hier können Sie die Basis anpassen, wo Ihre Welt gehostet wird. Diese
Implementierung Verwenden Sie das Docker-Image itzg / minecraft-server.
Argumente:
Befehl: Ein Minecraft-Befehl, z. B. "Hallo sagen"
"" "
Lauf(
[
"Docker", "Exec", "Mc", "Rcon-Cli",
Befehl
]]
)
def walk_spiral (Start: Tupel, Schritt: float = 16) -> Tupel:
"" "
Generieren Sie Positionen, zu denen Sie teleportieren möchten.
Dies ist ein unendlicher Generator.
Argumente:
Start: Ausgangsposition
Schritt: Länge der Sprünge.
Ausbeuten:
Position zum Teleportieren in einer Spirale.
"" "
current_movement_x, current_movement_z = start
Bewegungen = spiral_movements ()
während wahr:
Ausbeute current_movement_x, current_movement_z
next_x_movement, next_y_movement = next (Bewegungen)
current_movement_x + = next_x_movement * step
current_movement_z + = next_y_movement * step
def spiral_movements ():
def _spiral_distances ():
für Schritte in Zählung (1):
für _ in (0, 1):
Fließschritte
def _clockwise_directions ():
links = (-1, 0)
rechts = (1, 0)
up = (0, -1)
down = (0, 1)
Rücklaufzyklus ((rechts, unten, links, oben))
für Entfernung, Richtung in zip (_spiral_distances (), _clockwise_directions ()):
für _ in Reichweite (Entfernung):
Fließrichtung
if __name__ == "__main__":
Main()