Hallo.

Viele Leute möchten mit der Programmierung von Apps für Android beginnen, bevorzugen jedoch die Verwendung von Android Studio und / oder Java. Warum? Weil es ein Overkill ist. "Ich will nur Snake erschaffen und nichts weiter!"

Lass uns ohne Java schlängeln! (mit einem Bonus am Ende)

Warum noch ein Schlangen-Tutorial erstellen?

Wenn Sie ein Python-Codierer sind und Gamedev für Android lernen möchten, müssen Sie bereits "Schlange auf Android" gegoogelt und diese (Eng) oder deren Übersetzung (Rus) gefunden haben . Ich auch. Leider fand ich den Artikel äußerst nutzlos, weil:

Ihr Code ist schlecht

Kleinere Probleme:

Die Verwendung von "Kachel" und "Kopf" anstelle von "Kacheln" oder "Zellen" macht für mich keinen Sinn. Der Kopf unterscheidet sich nicht genug von der Kachel, um unterschiedliche Variablen zu sein.
Clock.schedule für self.update wird von ... self.update aufgerufen.
Der Spielplatz der zweiten Ebene wird am Anfang implementiert, während die SnakeApp der ersten Ebene am Ende implementiert wird.
Namen für Richtungen ("hoch", "runter", ...) werden anstelle von Vektoren ((0, 1), (1, 0) ...) verwendet.

Hauptprobleme:

Die meisten dynamischen Objekte (z. B. die Frucht) werden an die kv-Datei angehängt, sodass Sie nicht mehr als einen Apfel erstellen können, da Sie diesen Teil dann neu schreiben sollten
Seltsame Logik für die Bewegung der Schlange anstelle von "Zelle für Zelle".
Der Code ist sehr lang und umfasst mehr als 350 Zeilen.

Der Artikel ist für Anfänger nicht klar

Dies ist meine persönliche Meinung. Außerdem kann ich nicht garantieren, dass mein Tutorial interessanter und klarer wird. Aber ich werde mein Bestes geben und für meinen Artikel garantieren, dass:

Der Code ist kurz
Die Schlange ist nett
Die Anweisungen enthalten klare schrittweise Implementierungen und einen reibungslosen Übergang von "Hallo Welt" zu einer fertigen Schlange mit Übergangsschritten.

Das unerwünschte Ergebnis

Kein Platz zwischen den Zellen, das Dreieck ist peinlich, Grafiken sind fehlerhaft.

Machen Sie sich vertraut

Erste App

Bitte bestätigen Sie, dass Sie Kivy bereits installiert haben (falls nicht, befolgen Sie die Anweisungen ) und ausgeführt haben
buildozer init im Projektverzeichnis.

Lassen Sie uns unsere erste App ausführen:

main.py.

 from kivy.app import App from kivy.uix.widget import Widget class WormApp(App): def build(self): return Widget() if __name__ == '__main__': WormApp().run()

Wir haben ein Widget erstellt. Analog können wir eine Schaltfläche oder ein anderes UI-Element erstellen:

 from kivy.app import App from kivy.uix.widget import Widget from kivy.uix.button import Button class WormApp(App): def build(self): self.but = Button() self.but.pos = (100, 100) self.but.size = (200, 200) self.but.text = "Hello, cruel world" self.form = Widget() self.form.add_widget(self.but) return self.form if __name__ == '__main__': WormApp().run()

Wow! Glückwunsch! Sie haben einen Button erstellt!

.kv-Dateien

Es gibt jedoch eine andere Möglichkeit, UI-Elemente zu erstellen. Zunächst implementieren wir unser Formular:

 from kivy.app import App from kivy.uix.widget import Widget from kivy.uix.button import Button class Form(Widget): def __init__(self): super().__init__() self.but1 = Button() self.but1.pos = (100, 100) self.add_widget(self.but1) class WormApp(App): def build(self): self.form = Form() return self.form if __name__ == '__main__': WormApp().run()

Dann erstellen wir die Datei "worm.kv".

worm.kv

 <Form>: but2: but_id Button: id: but_id pos: (200, 200)

Was ist gerade passiert? Wir haben einen weiteren Button erstellt und die ID but_id zugewiesen. Dann wurde but_id mit but2 des Formulars abgeglichen. Dies bedeutet, dass wir jetzt mit but2 auf diese Schaltfläche verweisen können

 class Form(Widget): def __init__(self): super().__init__() self.but1 = Button() self.but1.pos = (100, 100) self.add_widget(self.but1) # self.but2.text = "OH MY"

Grafik

Als Nächstes erstellen wir ein grafisches Element. Zuerst implementieren wir es in worm.kv:

 <Form>: <Cell>: canvas: Rectangle: size: self.size pos: self.pos

Wir haben die Position des Rechtecks mit self.pos und seine Größe mit self.size verknüpft. Jetzt sind diese Eigenschaften in Cell verfügbar. Sobald wir beispielsweise eine Zelle erstellt haben, können wir dies tun

 class Cell(Widget): def __init__(self, x, y, size): super().__init__() self.size = (size, size) # As you can see, we can change self.size which is "size" property of a rectangle self.pos = (x, y) class Form(Widget): def __init__(self): super().__init__() self.cell = Cell(100, 100, 30) self.add_widget(self.cell)

Ok, wir haben eine Zelle erstellt.

Unnötige Methoden

Versuchen wir es zu bewegen. Dazu sollten wir die Funktion Form.update hinzufügen und planen.

 from kivy.app import App from kivy.uix.widget import Widget from kivy.clock import Clock class Cell(Widget): def __init__(self, x, y, size): super().__init__() self.size = (size, size) self.pos = (x, y) class Form(Widget): def __init__(self): super().__init__() self.cell = Cell(100, 100, 30) self.add_widget(self.cell) def start(self): Clock.schedule_interval(self.update, 0.01) def update(self, _): self.cell.pos = (self.cell.pos[0] + 2, self.cell.pos[1] + 3) class WormApp(App): def build(self): self.form = Form() self.form.start() return self.form if __name__ == '__main__': WormApp().run()

Die Zelle bewegt sich über das Formular. Wie Sie sehen, können wir jede Funktion mit Clock planen.

Als nächstes machen wir ein Touch-Ereignis. Form umschreiben:

 class Form(Widget): def __init__(self): super().__init__() self.cells = [] def start(self): Clock.schedule_interval(self.update, 0.01) def update(self, _): for cell in self.cells: cell.pos = (cell.pos[0] + 2, cell.pos[1] + 3) def on_touch_down(self, touch): cell = Cell(touch.x, touch.y, 30) self.add_widget(cell) self.cells.append(cell)

Jeder touch_down erstellt eine Zelle mit Koordinaten = (touch.x, touch.y) und einer Größe von 30. Anschließend fügen wir sie als Widget des Formulars AND zu unserem eigenen Array hinzu (um leicht darauf zugreifen zu können).

Jetzt können Sie auf Ihr Formular tippen und Zellen generieren.

Ordentliche Einstellungen

Da wir eine schöne Schlange haben wollen, sollten wir die grafischen Positionen und die tatsächlichen Positionen der Zellen unterscheiden.

Warum?

Viele Gründe dafür. Die gesamte Logik sollte mit den sogenannten tatsächlichen Daten verbunden sein, während die grafischen Daten das Ergebnis der tatsächlichen Daten sind. Wenn wir beispielsweise Ränder erstellen möchten, ist die tatsächliche Position der Zelle (100, 100), während die grafische Position des Rechtecks - (102, 102) ist.

PS Wir würden es nicht tun, wenn wir uns mit klassischem on_draw befassen würden. Aber hier müssen wir on_draw nicht programmieren.

Lassen Sie uns die Datei worm.kv reparieren:

 <Form>: <Cell>: canvas: Rectangle: size: self.graphical_size pos: self.graphical_pos

und main.py:

 ... from kivy.properties import * ... class Cell(Widget): graphical_size = ListProperty([1, 1]) graphical_pos = ListProperty([1, 1]) def __init__(self, x, y, size, margin=4): super().__init__() self.actual_size = (size, size) self.graphical_size = (size - margin, size - margin) self.margin = margin self.actual_pos = (x, y) self.graphical_pos_attach() def graphical_pos_attach(self): self.graphical_pos = (self.actual_pos[0] - self.graphical_size[0] / 2, self.actual_pos[1] - self.graphical_size[1] / 2) ... class Form(Widget): def __init__(self): super().__init__() self.cell1 = Cell(100, 100, 30) self.cell2 = Cell(130, 100, 30) self.add_widget(self.cell1) self.add_widget(self.cell2) ...

Der Rand wurde so angezeigt, dass er hübsch aussieht, obwohl wir die zweite Zelle mit X = 130 anstelle von 132 erstellt haben. Später werden wir basierend auf dem Abstand zwischen actual_pos und graphical_pos eine gleichmäßige Bewegung ausführen.

Den Wurm codieren

Implementierung

Init config in main.py

 class Config: DEFAULT_LENGTH = 20 CELL_SIZE = 25 APPLE_SIZE = 35 MARGIN = 4 INTERVAL = 0.2 DEAD_CELL = (1, 0, 0, 1) APPLE_COLOR = (1, 1, 0, 1)

(Vertrau mir, du wirst es lieben!)

Weisen Sie dann der App die Konfiguration zu:

 class WormApp(App): def __init__(self): super().__init__() self.config = Config() self.form = Form(self.config) def build(self): self.form.start() return self.form

Schreiben Sie init neu und starten Sie:

 class Form(Widget): def __init__(self, config): super().__init__() self.config = config self.worm = None def start(self): self.worm = Worm(self.config) self.add_widget(self.worm) Clock.schedule_interval(self.update, self.config.INTERVAL)

Dann die Zelle:

 class Cell(Widget): graphical_size = ListProperty([1, 1]) graphical_pos = ListProperty([1, 1]) def __init__(self, x, y, size, margin=4): super().__init__() self.actual_size = (size, size) self.graphical_size = (size - margin, size - margin) self.margin = margin self.actual_pos = (x, y) self.graphical_pos_attach() def graphical_pos_attach(self): self.graphical_pos = (self.actual_pos[0] - self.graphical_size[0] / 2, self.actual_pos[1] - self.graphical_size[1] / 2) def move_to(self, x, y): self.actual_pos = (x, y) self.graphical_pos_attach() def move_by(self, x, y, **kwargs): self.move_to(self.actual_pos[0] + x, self.actual_pos[1] + y, **kwargs) def get_pos(self): return self.actual_pos def step_by(self, direction, **kwargs): self.move_by(self.actual_size[0] * direction[0], self.actual_size[1] * direction[1], **kwargs)

Hoffentlich ist es mehr oder weniger klar.

und schließlich der Wurm:

 class Worm(Widget): def __init__(self, config): super().__init__() self.cells = [] self.config = config self.cell_size = config.CELL_SIZE self.head_init((100, 100)) for i in range(config.DEFAULT_LENGTH): self.lengthen() def destroy(self): for i in range(len(self.cells)): self.remove_widget(self.cells[i]) self.cells = [] def lengthen(self, pos=None, direction=(0, 1)): # If pos is set, we put the cell in pos, otherwise accordingly to the specified direction if pos is None: px = self.cells[-1].get_pos()[0] + direction[0] * self.cell_size py = self.cells[-1].get_pos()[1] + direction[1] * self.cell_size pos = (px, py) self.cells.append(Cell(*pos, self.cell_size, margin=self.config.MARGIN)) self.add_widget(self.cells[-1]) def head_init(self, pos): self.lengthen(pos=pos)

Geben wir unserem Wurm Leben.

Bewegung

Jetzt werden wir es bewegen.

Es ist einfach:

 class Worm(Widget): ... def move(self, direction): for i in range(len(self.cells) - 1, 0, -1): self.cells[i].move_to(*self.cells[i - 1].get_pos()) self.cells[0].step_by(direction)

 class Form(Widget): def __init__(self, config): super().__init__() self.config = config self.worm = None self.cur_dir = (0, 0) def start(self): self.worm = Worm(self.config) self.add_widget(self.worm) self.cur_dir = (1, 0) Clock.schedule_interval(self.update, self.config.INTERVAL) def update(self, _): self.worm.move(self.cur_dir)

Es lebt! Es lebt!

Steuern

Wie Sie anhand des Vorschaubilds beurteilen können, sind die Steuerelemente der Schlange wie folgt:

 class Form(Widget): ... def on_touch_down(self, touch): ws = touch.x / self.size[0] hs = touch.y / self.size[1] aws = 1 - ws if ws > hs and aws > hs: cur_dir = (0, -1) # Down elif ws > hs >= aws: cur_dir = (1, 0) # Right elif ws <= hs < aws: cur_dir = (-1, 0) # Left else: cur_dir = (0, 1) # Up self.cur_dir = cur_dir

Cool.

Frucht schaffen

Zuerst initialisieren wir es.

 class Form(Widget): ... def __init__(self, config): super().__init__() self.config = config self.worm = None self.cur_dir = (0, 0) self.fruit = None ... def random_cell_location(self, offset): x_row = self.size[0] // self.config.CELL_SIZE x_col = self.size[1] // self.config.CELL_SIZE return random.randint(offset, x_row - offset), random.randint(offset, x_col - offset) def random_location(self, offset): x_row, x_col = self.random_cell_location(offset) return self.config.CELL_SIZE * x_row, self.config.CELL_SIZE * x_col def fruit_dislocate(self): x, y = self.random_location(2) self.fruit.move_to(x, y) ... def start(self): self.fruit = Cell(0, 0, self.config.APPLE_SIZE, self.config.MARGIN) self.worm = Worm(self.config) self.fruit_dislocate() self.add_widget(self.worm) self.add_widget(self.fruit) self.cur_dir = (1, 0) Clock.schedule_interval(self.update, self.config.INTERVAL)

Das aktuelle Ergebnis:

Jetzt sollten wir einige Wurmmethoden implementieren:

 class Worm(Widget): ... # Here we get all the positions of our cells def gather_positions(self): return [cell.get_pos() for cell in self.cells] # Just check if our head has the same position as another Cell def head_intersect(self, cell): return self.cells[0].get_pos() == cell.get_pos()

Weitere Vorteile von collect_positions

Übrigens, nachdem wir collect_positions implementiert haben, können wir obst_dislocate ändern:

 class Form(Widget): def fruit_dislocate(self): x, y = self.random_location(2) while (x, y) in self.worm.gather_positions(): x, y = self.random_location(2) self.fruit.move_to(x, y)

Zu diesem Zeitpunkt befindet sich die Frucht nicht mehr auf der Kachel des Wurms.

... und füge diese Prüfung zu update () hinzu

 class Form(Widget): ... def update(self, _): self.worm.move(self.cur_dir) if self.worm.head_intersect(self.fruit): directions = [(0, 1), (0, -1), (1, 0), (-1, 0)] self.worm.lengthen(direction=random.choice(directions)) self.fruit_dislocate()

Erkennung von Selbstkacheln

Wir wollen wissen, ob der Kopf die gleiche Position wie eine der Wurmzellen hat.

 class Form(Widget): ... def __init__(self, config): super().__init__() self.config = config self.worm = None self.cur_dir = (0, 0) self.fruit = None self.game_on = True def update(self, _): if not self.game_on: return self.worm.move(self.cur_dir) if self.worm.head_intersect(self.fruit): directions = [(0, 1), (0, -1), (1, 0), (-1, 0)] self.worm.lengthen(direction=random.choice(directions)) self.fruit_dislocate() if self.worm_bite_self(): self.game_on = False def worm_bite_self(self): for cell in self.worm.cells[1:]: if self.worm.head_intersect(cell): return cell return False

Färben, Dekorieren und Code-Refactoring

Beginnen wir mit dem Code-Refactoring.

Umschreiben und hinzufügen

 class Form(Widget): ... def start(self): self.worm = Worm(self.config) self.add_widget(self.worm) if self.fruit is not None: self.remove_widget(self.fruit) self.fruit = Cell(0, 0, self.config.APPLE_SIZE) self.fruit_dislocate() self.add_widget(self.fruit) Clock.schedule_interval(self.update, self.config.INTERVAL) self.game_on = True self.cur_dir = (0, -1) def stop(self): self.game_on = False Clock.unschedule(self.update) def game_over(self): self.stop() ... def on_touch_down(self, touch): if not self.game_on: self.worm.destroy() self.start() return ...

Wenn der Wurm tot (eingefroren) ist und Sie erneut auf tippen, wird das Spiel zurückgesetzt.

Gehen wir nun zum Dekorieren und Färben.

worm.kv

 <Form>: popup_label: popup_label score_label: score_label canvas: Color: rgba: (.5, .5, .5, 1.0) Line: width: 1.5 points: (0, 0), self.size Line: width: 1.5 points: (self.size[0], 0), (0, self.size[1]) Label: id: score_label text: "Score: " + str(self.parent.worm_len) width: self.width Label: id: popup_label width: self.width <Worm>: <Cell>: canvas: Color: rgba: self.color Rectangle: size: self.graphical_size pos: self.graphical_pos

WormApp neu schreiben:

 class WormApp(App): def build(self): self.config = Config() self.form = Form(self.config) return self.form def on_start(self): self.form.start()

Lass es uns färben. Zelle in .kv umschreiben:

 <Cell>: canvas: Color: rgba: self.color Rectangle: size: self.graphical_size pos: self.graphical_pos

Fügen Sie dies zu Zelle .__ init__ hinzu

 self.color = (0.2, 1.0, 0.2, 1.0) #

und dies zu Form.start

 self.fruit.color = (1.0, 0.2, 0.2, 1.0)

Großartig, genieße deine Schlange

Schließlich werden wir ein "Game Over" -Label machen

 class Form(Widget): ... def __init__(self, config): ... self.popup_label.text = "" ... def stop(self, text=""): self.game_on = False self.popup_label.text = text Clock.unschedule(self.update) def game_over(self): self.stop("GAME OVER" + " " * 5 + "\ntap to reset")

und mache die Trefferzelle rot:

statt

  def update(self, _): ... if self.worm_bite_self(): self.game_over() ...

schreibe

  def update(self, _): cell = self.worm_bite_self() if cell: cell.color = (1.0, 0.2, 0.2, 1.0) self.game_over()

Passst du immer noch auf? Als nächstes kommt der interessanteste Teil.

Bonusbereich - reibungslose Bewegung

Da der Schritt des Wurms gleich der Zellengröße ist, ist er nicht so glatt. Aber wir wollen es so oft wie möglich machen, ohne die gesamte Logik des Spiels neu zu schreiben. Wir müssen also einen Mechanismus erstellen, der unsere grafischen Posen bewegt, aber nicht unsere tatsächlichen Posen. Also schrieb ich eine einfache Datei:

glatt.py

 from kivy.clock import Clock import time class Timing: @staticmethod def linear(x): return x class Smooth: def __init__(self, interval=1.0/60.0): self.objs = [] self.running = False self.interval = interval def run(self): if self.running: return self.running = True Clock.schedule_interval(self.update, self.interval) def stop(self): if not self.running: return self.running = False Clock.unschedule(self.update) def setattr(self, obj, attr, value): exec("obj." + attr + " = " + str(value)) def getattr(self, obj, attr): return float(eval("obj." + attr)) def update(self, _): cur_time = time.time() for line in self.objs: obj, prop_name_x, prop_name_y, from_x, from_y, to_x, to_y, start_time, period, timing = line time_gone = cur_time - start_time if time_gone >= period: self.setattr(obj, prop_name_x, to_x) self.setattr(obj, prop_name_y, to_y) self.objs.remove(line) else: share = time_gone / period acs = timing(share) self.setattr(obj, prop_name_x, from_x * (1 - acs) + to_x * acs) self.setattr(obj, prop_name_y, from_y * (1 - acs) + to_y * acs) if len(self.objs) == 0: self.stop() def move_to(self, obj, prop_name_x, prop_name_y, to_x, to_y, t, timing=Timing.linear): self.objs.append((obj, prop_name_x, prop_name_y, self.getattr(obj, prop_name_x), self.getattr(obj, prop_name_y), to_x, to_y, time.time(), t, timing)) self.run() class XSmooth(Smooth): def __init__(self, props, timing=Timing.linear, *args, **kwargs): super().__init__(*args, **kwargs) self.props = props self.timing = timing def move_to(self, obj, to_x, to_y, t): super().move_to(obj, *self.props, to_x, to_y, t, timing=self.timing)

Für diejenigen, die meinen Code nicht mögen

Dieses Modul ist nicht die eleganteste Lösung ©. Es ist eine schlechte Lösung und ich erkenne es an. Es ist eine Nur-Hallo-Welt-Lösung.

Sie erstellen also einfach glatt.py und kopieren diesen Code in die Datei.
Lassen Sie es zum Schluss funktionieren:

 class Form(Widget): ... def __init__(self, config): ... self.smooth = smooth.XSmooth(["graphical_pos[0]", "graphical_pos[1]"])

Dann ersetzen wir self.worm.move () durch

 class Form(Widget): ... def update(self, _): ... self.worm.move(self.cur_dir, smooth_motion=(self.smooth, self.config.INTERVAL))

Und so sollten Methoden von Cell aussehen

 class Cell(Widget): ... def graphical_pos_attach(self, smooth_motion=None): to_x, to_y = self.actual_pos[0] - self.graphical_size[0] / 2, self.actual_pos[1] - self.graphical_size[1] / 2 if smooth_motion is None: self.graphical_pos = to_x, to_y else: smoother, t = smooth_motion smoother.move_to(self, to_x, to_y, t) def move_to(self, x, y, **kwargs): self.actual_pos = (x, y) self.graphical_pos_attach(**kwargs) def move_by(self, x, y, **kwargs): self.move_to(self.actual_pos[0] + x, self.actual_pos[1] + y, **kwargs)

Das war's, danke für deine Aufmerksamkeit!

So funktioniert das Endergebnis:

Der endgültige Code

main.py.

 from kivy.app import App from kivy.uix.widget import Widget from kivy.clock import Clock from kivy.properties import * import random import smooth class Cell(Widget): graphical_size = ListProperty([1, 1]) graphical_pos = ListProperty([1, 1]) color = ListProperty([1, 1, 1, 1]) def __init__(self, x, y, size, margin=4): super().__init__() self.actual_size = (size, size) self.graphical_size = (size - margin, size - margin) self.margin = margin self.actual_pos = (x, y) self.graphical_pos_attach() self.color = (0.2, 1.0, 0.2, 1.0) def graphical_pos_attach(self, smooth_motion=None): to_x, to_y = self.actual_pos[0] - self.graphical_size[0] / 2, self.actual_pos[1] - self.graphical_size[1] / 2 if smooth_motion is None: self.graphical_pos = to_x, to_y else: smoother, t = smooth_motion smoother.move_to(self, to_x, to_y, t) def move_to(self, x, y, **kwargs): self.actual_pos = (x, y) self.graphical_pos_attach(**kwargs) def move_by(self, x, y, **kwargs): self.move_to(self.actual_pos[0] + x, self.actual_pos[1] + y, **kwargs) def get_pos(self): return self.actual_pos def step_by(self, direction, **kwargs): self.move_by(self.actual_size[0] * direction[0], self.actual_size[1] * direction[1], **kwargs) class Worm(Widget): def __init__(self, config): super().__init__() self.cells = [] self.config = config self.cell_size = config.CELL_SIZE self.head_init((100, 100)) for i in range(config.DEFAULT_LENGTH): self.lengthen() def destroy(self): for i in range(len(self.cells)): self.remove_widget(self.cells[i]) self.cells = [] def lengthen(self, pos=None, direction=(0, 1)): if pos is None: px = self.cells[-1].get_pos()[0] + direction[0] * self.cell_size py = self.cells[-1].get_pos()[1] + direction[1] * self.cell_size pos = (px, py) self.cells.append(Cell(*pos, self.cell_size, margin=self.config.MARGIN)) self.add_widget(self.cells[-1]) def head_init(self, pos): self.lengthen(pos=pos) def move(self, direction, **kwargs): for i in range(len(self.cells) - 1, 0, -1): self.cells[i].move_to(*self.cells[i - 1].get_pos(), **kwargs) self.cells[0].step_by(direction, **kwargs) def gather_positions(self): return [cell.get_pos() for cell in self.cells] def head_intersect(self, cell): return self.cells[0].get_pos() == cell.get_pos() class Form(Widget): worm_len = NumericProperty(0) def __init__(self, config): super().__init__() self.config = config self.worm = None self.cur_dir = (0, 0) self.fruit = None self.game_on = True self.smooth = smooth.XSmooth(["graphical_pos[0]", "graphical_pos[1]"]) def random_cell_location(self, offset): x_row = self.size[0] // self.config.CELL_SIZE x_col = self.size[1] // self.config.CELL_SIZE return random.randint(offset, x_row - offset), random.randint(offset, x_col - offset) def random_location(self, offset): x_row, x_col = self.random_cell_location(offset) return self.config.CELL_SIZE * x_row, self.config.CELL_SIZE * x_col def fruit_dislocate(self): x, y = self.random_location(2) while (x, y) in self.worm.gather_positions(): x, y = self.random_location(2) self.fruit.move_to(x, y) def start(self): self.worm = Worm(self.config) self.add_widget(self.worm) if self.fruit is not None: self.remove_widget(self.fruit) self.fruit = Cell(0, 0, self.config.APPLE_SIZE) self.fruit.color = (1.0, 0.2, 0.2, 1.0) self.fruit_dislocate() self.add_widget(self.fruit) self.game_on = True self.cur_dir = (0, -1) Clock.schedule_interval(self.update, self.config.INTERVAL) self.popup_label.text = "" def stop(self, text=""): self.game_on = False self.popup_label.text = text Clock.unschedule(self.update) def game_over(self): self.stop("GAME OVER" + " " * 5 + "\ntap to reset") def align_labels(self): try: self.popup_label.pos = ((self.size[0] - self.popup_label.width) / 2, self.size[1] / 2) self.score_label.pos = ((self.size[0] - self.score_label.width) / 2, self.size[1] - 80) except: print(self.__dict__) assert False def update(self, _): if not self.game_on: return self.worm.move(self.cur_dir, smooth_motion=(self.smooth, self.config.INTERVAL)) if self.worm.head_intersect(self.fruit): directions = [(0, 1), (0, -1), (1, 0), (-1, 0)] self.worm.lengthen(direction=random.choice(directions)) self.fruit_dislocate() cell = self.worm_bite_self() if cell: cell.color = (1.0, 0.2, 0.2, 1.0) self.game_over() self.worm_len = len(self.worm.cells) self.align_labels() def on_touch_down(self, touch): if not self.game_on: self.worm.destroy() self.start() return ws = touch.x / self.size[0] hs = touch.y / self.size[1] aws = 1 - ws if ws > hs and aws > hs: cur_dir = (0, -1) elif ws > hs >= aws: cur_dir = (1, 0) elif ws <= hs < aws: cur_dir = (-1, 0) else: cur_dir = (0, 1) self.cur_dir = cur_dir def worm_bite_self(self): for cell in self.worm.cells[1:]: if self.worm.head_intersect(cell): return cell return False class Config: DEFAULT_LENGTH = 20 CELL_SIZE = 25 APPLE_SIZE = 35 MARGIN = 4 INTERVAL = 0.3 DEAD_CELL = (1, 0, 0, 1) APPLE_COLOR = (1, 1, 0, 1) class WormApp(App): def build(self): self.config = Config() self.form = Form(self.config) return self.form def on_start(self): self.form.start() if __name__ == '__main__': WormApp().run()

glatt.py

 from kivy.clock import Clock import time class Timing: @staticmethod def linear(x): return x class Smooth: def __init__(self, interval=1.0/60.0): self.objs = [] self.running = False self.interval = interval def run(self): if self.running: return self.running = True Clock.schedule_interval(self.update, self.interval) def stop(self): if not self.running: return self.running = False Clock.unschedule(self.update) def setattr(self, obj, attr, value): exec("obj." + attr + " = " + str(value)) def getattr(self, obj, attr): return float(eval("obj." + attr)) def update(self, _): cur_time = time.time() for line in self.objs: obj, prop_name_x, prop_name_y, from_x, from_y, to_x, to_y, start_time, period, timing = line time_gone = cur_time - start_time if time_gone >= period: self.setattr(obj, prop_name_x, to_x) self.setattr(obj, prop_name_y, to_y) self.objs.remove(line) else: share = time_gone / period acs = timing(share) self.setattr(obj, prop_name_x, from_x * (1 - acs) + to_x * acs) self.setattr(obj, prop_name_y, from_y * (1 - acs) + to_y * acs) if len(self.objs) == 0: self.stop() def move_to(self, obj, prop_name_x, prop_name_y, to_x, to_y, t, timing=Timing.linear): self.objs.append((obj, prop_name_x, prop_name_y, self.getattr(obj, prop_name_x), self.getattr(obj, prop_name_y), to_x, to_y, time.time(), t, timing)) self.run() class XSmooth(Smooth): def __init__(self, props, timing=Timing.linear, *args, **kwargs): super().__init__(*args, **kwargs) self.props = props self.timing = timing def move_to(self, obj, to_x, to_y, t): super().move_to(obj, *self.props, to_x, to_y, t, timing=self.timing)

worm.kv

 <Form>: popup_label: popup_label score_label: score_label canvas: Color: rgba: (.5, .5, .5, 1.0) Line: width: 1.5 points: (0, 0), self.size Line: width: 1.5 points: (self.size[0], 0), (0, self.size[1]) Label: id: score_label text: "Score: " + str(self.parent.worm_len) width: self.width Label: id: popup_label width: self.width <Worm>: <Cell>: canvas: Color: rgba: self.color Rectangle: size: self.graphical_size pos: self.graphical_pos

Code, angepasst von @tshirtman

Ich habe einige Probleme mit meinem Code erhalten, zum Beispiel hat mir tshirtman, einer der Mitwirkenden des Kivy-Projekts, vorgeschlagen, keine Zellen als Widgets zu erstellen, sondern stattdessen eine Point-Anweisung zu erstellen. Ich finde diesen Code jedoch nicht einfacher zu verstehen als meinen, obwohl er in Bezug auf die Benutzeroberfläche und die Spieleentwicklung definitiv besser ist. Wie auch immer, der Code: