Domanda:
Come faccio a pre-generare un mondo di Minecraft?
Fox32
2011-10-12 20:36:27 UTC
view on stackexchange narkive permalink

Voglio creare un nuovo mondo sul nostro server Minecraft, ma esplorare una nuova mappa e generare terreno provoca un enorme ritardo.

Esiste un modo per pre-generare i blocchi (con il generatore di mappe predefinito) in un raggio specifico attorno allo spawn?

Sto cercando un plug-in o uno strumento Bukkit che posso usare sulla nostra macchina Linux. Va bene anche uno strumento offline che posso eseguire sulla mia macchina locale.

Dieci risposte:
#1
+28
Brant
2011-10-12 20:57:06 UTC
view on stackexchange narkive permalink

In questo thread su Reddit, ho trovato uno script della riga di comando che genererà terreno riavviando ripetutamente un server con diversi punti di spawn fino a riempire l'area specificata. Questo sembra proprio quello che stai cercando.

C'è anche un plugin Bukkit chiamato WorldGenerationControl che può farlo su un server live.

per i futuri lettori, lo script della riga di comando (gist) non esiste e WGC è obsoleto
Boo. È deludente.
lo script della riga di comando si trova su https://github.com/DMBuce/mcexplore
Grazie mille @glob!Avevo bisogno di uno script come questo che funzionasse molto male con i server modificati la scorsa notte.
Il [WorldGenerationControl link] (http://dev.bukkit.org/server-mods/worldgenerationcontrol/) non funziona più
#2
+8
John Hopkins
2013-12-08 10:52:03 UTC
view on stackexchange narkive permalink

È lento, ma puoi teletrasportarti automaticamente attraverso tutti i blocchi in un'area specifica della mappa per averli generati usando Python e il modulo pexpect (che ho usato per inviare i comandi di teletrasporto).

Per prima cosa, crea una copia dei tuoi dati di gioco a scopo di test, quindi apri un prompt dei comandi in quella directory e procedi come segue:

$ virtualenv venv

$ source venv / bin / activation

$ pip install pexpect

Incolla questo codice in teleport-wait. py (regola il nome del giocatore e gli intervalli xcoord e zcoord):

  #! / usr / bin / pythonimport sysimport pexpectimport time # imposta questo valore sul tuo minecraft usernameplayername = 'yourplayername'child = pexpect.spawn ( 'java -Xms2048M -Xmx2048M -jar minecraft_server.jar nogui') child.logfile = sys.stdoutchild.expect ('% s si è unito al gioco'% playername) child.sendline ('gamemode 1% s'% playername) per xcoord in intervallo (1000000, 1005000, 16): per zcoord nell'intervallo (1000000, 1005000, 16): ch ild.sendline ('tp% s% i 255% i'% (playername, xcoord, zcoord)) child.expect ('Teleported% s'% playername) # Tempo tra i teletrasporti. Un valore inferiore significa maggiore stress per il server. time.sleep (0.5) child.sendline ('dì tutto fatto!')  

$ python teleport-expect.py

Una volta il server si avvia, accedi al gioco. Dovresti vedere il tuo giocatore teletrasportato automaticamente un pezzo alla volta nell'area di interesse. Visitare un'area 5000x5000 richiederà più ore per correre.

Non è un modo veloce per generare una mappa, ma semplice per vedere lo scenario volare. Volevo principalmente testare l'esecuzione del server Minecraft all'interno di una sessione pexpect. Un sacco di potenziale per altre automazioni (ad esempio, guardare i comandi creati dall'utente su un server vanilla)!

#3
+5
Morlok8k
2012-06-20 01:22:34 UTC
view on stackexchange narkive permalink

Minecraft Land Generator:

espande il tuo attuale mondo vaniglia (o modificato se hai le mod del server).

http://www.minecraftforum.net/ topic / 187737-minecraft-land-generator /

Non più supportato :( http://www.minecraftforum.net/forums/mapping-and-modding/minecraft-tools/1261072-minecraft-land-generator?comment=1257
#4
+3
Zsub
2011-10-12 20:50:58 UTC
view on stackexchange narkive permalink

Un modo totalmente vanigliato sarebbe generare un mondo in singleplayer ed esplorarlo manualmente. Questo ovviamente richiederà molto lavoro :)

Non sono a conoscenza di altri metodi.

Se lo fai, è molto più veloce farlo in modalità Creativa, dove puoi volare e creare mappe in qualsiasi punto per tenere traccia dei tuoi progressi. La compilazione di una mappa richiede circa 10 minuti in volo per ~ 25 MB di blocchi.
Questo può essere combinato con [Single Player Commands '] (http://www.minecraftforum.net/topic/94310-181-single-player-commands-v2121-mcp-pack-updated/) comandi di teletrasporto per ridurre drasticamente il tempo necessario.
Non sono sicuro del motivo per cui questa è una risposta.OP sta ovviamente cercando un metodo per pre-generare automaticamente il suo mondo.Esplorarlo manualmente, anche con la modalità creativa, è essenzialmente l'esatto opposto di questo.
#5
+2
Saiboogu
2011-12-10 18:42:11 UTC
view on stackexchange narkive permalink

Il plug-in WorldBorder per Bukkit ti consente di impostare una dimensione della mappa predefinita (misurata in raggio dallo spawn) e, facoltativamente, generare automaticamente il terreno all'interno dei tuoi confini.

Genera automaticamente il terreno in background mentre il server è in esecuzione. Ci sono volute circa 24 ore per generare il mio raggio di 3000 blocchi intorno al mondo su un server quad core con 4 GB assegnati a Minecraft. Sembrava che la memoria fosse il fattore limitante: sarebbe stata più veloce delle routine GC di Java e avrebbe dovuto fare una pausa periodica per attendere che la memoria si liberasse di nuovo. Forzare il riavvio di un server quando l'utilizzo della memoria diventava elevato lo ha reso più veloce, ma alla fine l'ho semplicemente ignorato ed è riuscito a finire da solo.

Consiglio di utilizzare WorldGenerationControl, è molto più veloce! Abbiamo combinato plug-in booth sul nostro server, WorldGenerationControl per generare il mondo e WorldBorder per mantenerlo in dimensioni.
@Fox32 dovrò verificarlo, grazie.
Il plug-in WorldBorder è ora obsoleto
#6
+1
Aqueries
2014-08-17 10:46:58 UTC
view on stackexchange narkive permalink

Un modo migliore per farlo ora è procurarsi una copia di mcedit da http://www.mcedit.net/ e aprire il tuo mondo con quello. scarica una copia del file jar del server di minecraft (poiché quello fornito con MCedit è della 1.5.2) e inseriscilo in \ ServerJarStorage \ release. assicurati che il jar si chiami "minecraft_server.jar" Quindi usa semplicemente lo strumento Chunk Generator per generare nuovi blocchi di una mappa esistente. Oppure puoi usare mcedit per generare una mappa completamente nuova.

#7
+1
juliantjan
2017-06-17 09:37:34 UTC
view on stackexchange narkive permalink

enter image description here

  #! / usr / bin / python

import sys
import pexpect
tempo di importazione

# impostalo sul tuo nome utente di Minecraft
playername = 'yourplayername'

figlio = pexpect.spawn ('java -Xms2048M -Xmx2048M -jar minecraft_server.jar nogui')
child.logfile = sys.stdout
child.expect ('% s si è unito al gioco'% playername)
child.sendline ('gamemode 1% s'% playername)

per xcoord nell'intervallo (1000000, 1005000, 16):
    per zcoord nell'intervallo (1000000, 1005000, 16):
        child.sendline ('tp% s% i 255% i'% (playername, xcoord, zcoord))
        child.expect ('% s'% playername teletrasportato)
        # Tempo tra i teletrasporti.Un valore inferiore significa maggiore stress per il server.
        time.sleep (0,5)
child.sendline ('dì tutto fatto!')
 
#8
+1
Matthew
2020-03-09 10:21:18 UTC
view on stackexchange narkive permalink

Non c'è modo di pre-generare i blocchi.I blocchi vengono generati SOLO quando un giocatore si trova in quel blocco e nella distanza di rendering visuale.Per quanto riguarda il lag che di solito dura solo un paio di giorni di gioco e di solito non è così male su server con hardware adeguato.In ogni caso la pre-generazione del mondo intero occuperebbe molto spazio.Una mappa 50k x 50k occupa circa 400 GB di spazio su disco rigido e il valore predefinito 29999984 occuperebbe circa 100 TB di spazio su disco rigido.Basta fare una griglia dell'area che si desidera generare e lasciare che il resto accada man mano che il gioco procede.Puoi usare i blocchi di comando per farlo.Cerca il video su YouTube.

#9
  0
abstrus
2019-05-20 07:50:27 UTC
view on stackexchange narkive permalink

Ecco una versione, ispirata a quella pexpect sopra.

Per eseguire, usa Python 3 e installa clic (magari in un ambiente virtuale). Quindi, trova aiuto nella riga di comando:

  $ python explore.py --help
Utilizzo: explore.py [OPTIONS]

  Viaggia nel tuo mondo di Minecraft

Opzioni:
  -p, --player TESTO Imposta questo un nome del giocatore di Minecraft registrato
  -s, --start TEXT Punto di partenza x: z
  -r, --radius INTEGER Larghezza del mondo che vuoi generare
  --help Mostra questo messaggio ed esce.
 

Partendo da un punto, teletrasporterà un giocatore in una spirale verso l'esterno passo dopo passo fino a raggiungere una certa larghezza.

Il codice seguente presume che il tuo mondo sia in esecuzione in una immagine docker. Modifica la funzione run_mc_command per adattarla al tuo hosting.

È lento: la generazione di un mondo 1000x1000 è (1000/16) ^ 2 = 3906 teletrasporti di almeno mezzo secondo ciascuno.

Ecco il codice:

  #! / usr / bin / python

da esecuzione di importazione sottoprocesso

from itertools import cycle, count

clic di importazione


@ click.command ()
@ click.option ("- p", "--player",
              help = "Imposta come nome del giocatore di Minecraft che ha effettuato l'accesso")
@ click.option ("- s", "--start",
              help = "Punto di partenza x: z",
              predefinito = "0: 0")
@ click.option ("- r", "--radius",
              help = "Larghezza del mondo che vuoi generare",
              valore predefinito = 5000)
def main (player: str, start: str, radius):
    "" "Viaggia nel tuo mondo di Minecraft" ""
    start = start.split (":", 2)
    parsed_start = float (start [0]), float (start [1])

    click.echo ("Exploring world")
    click.echo (f "Puppeteering {player! s}")
    click.echo (f "A partire da {parsed_start! s}")
    click.echo (f "Fino a raggiungere {raggio! s} metri di raggio (quadrato, ovviamente)")
    explore (player, parsed_start, float (radius))


def explore (player: str, start: tuple, width: float, step: float = 16) -> Nessuno:
    "" "
    Viaggia nel tuo mondo minecaft

    Argomenti:
giocatore: un giocatore connesso verrà teletrasportato. Questo è il nome del giocatore.
        inizio: coordinata iniziale (x, z).
        larghezza: larghezza del quadrato che vuoi esplorare.
        step: lunghezza dei salti. Il valore predefinito è 16 blocchi Minecraft.
    "" "
    run_mc_command (f "creatività gamemode {player! s}")
    per posizione in walk_spiral (start, step):
        run_mc_command (f "tp {player! s} {position [0]! s} 255 {position [1]! s}")
        distanza = posizione [0] - inizio [0], posizione [1] - inizio [1]
        se distanza [0] Larghezza >:
            rompere


def run_mc_command (comando: str) -> Nessuno:
    "" "
    Esegui un comando della console di Minecraft ..

    Qui puoi personalizzare la base su dove è ospitato il tuo mondo. Questo
    implementazione usa l'immagine docker itzg / minecraft-server.

    Argomenti:
        comando: un comando di Minecraft, come "dì ciao"
    "" "
    correre(
        [
            "docker", "exec", "mc", "rcon-cli",
            comando
        ]
    )


def walk_spiral (start: tuple, step: float = 16) -> tuple:
    "" "
    Genera posizioni in cui teletrasportarti.

    Questo è un generatore infinito.

    Argomenti:
        inizio: posizione di partenza
        step: lunghezza dei salti.

    Rendimenti:
        Posizione in cui teletrasportarsi in una spirale.
    "" "
    current_movement_x, current_movement_z = inizio
    movimenti = spiral_movements ()

    mentre True:
        rendimento current_movement_x, current_movement_z
        next_x_movement, next_y_movement = next (movimenti)
        current_movement_x + = next_x_movement * step
        current_movement_z + = next_y_movement * step


def spiral_movements ():

    def _spiral_distances ():
        per passi nel conteggio (1):
            per _ in (0, 1):
                passi di resa

    def _clockwise_directions ():
        sinistra = (-1, 0)
        destra = (1, 0)
        su = (0, -1)
        giù = (0, 1)
        ciclo di ritorno ((destra, giù, sinistra, su))

    per distanza, direzione in zip (_spiral_distances (), _clockwise_directions ()):
        per _ nell'intervallo (distanza):
            direzione di resa


se __name__ == "__main__":
principale()
 
#10
  0
Steffen Bauer
2020-06-23 21:03:25 UTC
view on stackexchange narkive permalink

In questo video viene mostrato uno script Datapack / Commandblock che teletrasporta un giocatore per generare Chunk.Questo metodo non è molto veloce ma porta a termine il lavoro.

Qui puoi scaricarlo.

La versione 1.15 V2 ha funzionato per me nella 1.16



Questa domanda e risposta è stata tradotta automaticamente dalla lingua inglese. Il contenuto originale è disponibile su stackexchange, che ringraziamo per la licenza cc by-sa 3.0 con cui è distribuito.
Loading...