Meisterung der Kaktus-Automatisierung: 2D-Blasensortierung

Der Kaktusanbau ist einzigartig, da das Sortieren nach Größe bessere Belohnungen bringen kann. Dieser Leitfaden erklärt, wie man Bubble Sort anwendet.

Die Strategie

Im Gegensatz zu anderen Pflanzen reicht das bloße Ernten von Kakteen nicht aus. Wir müssen sie messen und tauschen.

  • Messen: Vergleiche aktuelle Kaktusgröße mit Nachbarn.
  • Tauschen: Wenn der aktuelle größer ist, tausche sie.
  • Wiederholen: Wiederhole dies über das Raster.
Cactus Sorting Visualization

Schritt-für-Schritt Code-Analyse

Step 1 Intelligente Navigation

Vor dem Sortieren benötigen wir Hilfsfunktionen.

python
def back(x=0,y=0):
    while x!=get_pos_x() or y!=get_pos_y():
        if(get_pos_x()<x):
            move(East)
        else:
            move(West)
        if(get_pos_y()<y):
            move(North)
        else:
            move(South)

def reverse(dir):
    if(dir == West): return East
    if(dir == East): return West
    if(dir == North): return South
    if(dir == South): return North

Step 2 Kern-Sortierlogik

Das ist das Gehirn des Codes. Es prüft horizontal und vertikal.

python
# ... inside the loop
current=measure()
neighbor=measure(dir)
down=measure(South)
up=measure(North)

# Swap Horizontal (水平交换)
if(x!=size-1 and neighbor!=None and dir==East and current>neighbor):
    swap(East)
    sorted=False # Mark as not fully sorted yet

# Swap Vertical (垂直交换)
if(y!=0 and down != None and current<down):
    swap(South)
    vsorted=False

Vollständiger Quellcode

Python
python
def back(x=0,y=0):
    while x!=get_pos_x() or y!=get_pos_y():
        if(get_pos_x()<x):
            move(East)
        else:
            move(West)
        if(get_pos_y()<y):
            move(North)
        else:
            move(South)

def plantCactus():
    if get_ground_type()==Grounds.Grassland:
        till()
    plant(Entities.Cactus)  

def reverse(dir):
    if(dir == West): return East
    if(dir == East): return West
    if(dir == North): return South
    if(dir == South): return North

def cactusProject(size=3):
    while True:
        dir=East
        vdir=North
        sorted=False
        vsorted=False
        
        # 1. Planting Phase
        for i in range(size):
            for j in range(size):
                plantCactus()
                if(j!=size-1):
                    move(dir)
            if(i!=size-1):
                move(vdir)
            dir=reverse(dir)
        vdir=reverse(vdir)
        
        # 2. Sorting Phase
        while not sorted or not vsorted:
            sorted=True
            vsorted=True
            for i in range(size):
                for j in range(size):
                    x=get_pos_x()
                    y=get_pos_y()
                    current=measure()
                    neighbor=measure(dir)
                    down=measure(South)
                    up=measure(North)
                    
                    # Logic to swap East/West
                    if(x!=size-1 and neighbor!=None and dir==East and current>neighbor):
                        swap(East)
                        sorted=False
                    if(x!=0 and neighbor!=None and dir==West and current<neighbor):
                        swap(West)
                        sorted=False
                        
                    # Logic to swap North/South
                    if(y!=0 and down != None and current<down):
                        swap(South)
                        vsorted=False
                    if(y!=size-1 and up != None and current>up):
                        swap(North)
                        vsorted=False
                        
                    if(j!=size-1):
                        move(dir)
                if(i!=size-1):
                    move(vdir)
                dir=reverse(dir)
        
        # 3. Harvesting Phase (Once sorted)
        back()
        harvest()
        
clear()
# Change '6' to your grid size
cactusProject(6)

Optimierungstipps

  • • Stellen Sie sicher, dass der Parameter `size` mit der tatsächlichen Landgröße übereinstimmt.
  • • Dieser Algorithmus könnte auf großen Rastern langsam sein.
← Zurück zur Startseite