... atau cara menghabiskan waktu dengan iPad dan tidak lebih ...Hai
Apa yang kamu bicarakan
Sayangnya, tablet belum menggantikan komputer. Tetapi memiliki tumpangan / penerbangan sangat penting. Oleh karena itu, saya mencari apa yang ada di bawah iPad, dan sebenarnya hari ini saya akan melakukan permainan di Pythonista.
Apa yang akan kita lakukan
Program yang paling sederhana, seperti kristal (ya, ya, yang Anda mainkan di kereta bawah tanah). Tetris, ular, isi - pendatang baru, memiliki sedikit pemahaman, akan menulisnya dalam 30 menit. Di bawah cutscene - tangkapan layar, tutorial, kode.
Berikut adalah beberapa tangkapan layar dari apa yang saya buat kacau:
PenafianArtikel ini tidak hanya khusus untuk pemula (tetapi mengetahui python) dan tidak akan memungkinkan Anda untuk membuat dunia tank dalam sepuluh menit atau aplikasi siap pakai pada umumnya, tetapi penulis tidak menjamin kode yang benar-benar indah dan benar dari sudut pandang pemrograman agama (walaupun ia mencoba) . Dan juga ada sesuatu yang dicuri dari contoh dan dokumentasi pythonista.
Semua kode akan diberikan di akhir.Mengenal gambar dalam pythonista
Imporfrom scene import * import random
Segera buat heboh:
class Game(Scene): def setup(self): self.background_color = "green" run(Game(), LANDSCAPE)
Baiklah, mari kita mulai segera. Anda harus memiliki layar hijau. Mari kita lakukan beberapa hal keren dengan menambahkan metode pembaruan (yang disebut sistem itu sendiri) ke kelas Game, dan mengubah warna latar belakangnya.
class Game(Scene):
Sekarang layar kita dengan lancar berubah dari kuning menjadi putih dan sebaliknya.
Sekarang buat beberapa objek. Kami juga membuatnya dalam metode pengaturan:
class Game(Scene): def setup(self): self.background_color = "white" mypath = ui.Path.rect(0, 0, 50, 50) self.obj = ShapeNode(mypath) self.obj.color = "purple"
Kami mengatur garis (mypath), membuat ShapeNode di atasnya, menunjukkan warnanya, dan kemudian menentukan induknya (pada dasarnya hal yang sama - tentukan induknya saat membuat, mis. ShapeNode (* ..., parent = self) atau self.add_child (obj)).
Nah, di Game.update () kami mengubah posisi objek (tuple), dan itu dalam piksel dan dihitung dari sudut kiri bawah.
Perhatikan bahwa kita tidak perlu menggambar ulang adegan (meskipun dimungkinkan). Objek dan node yang orang tuanya adalah adegan (atau beberapa objek anaknya) digambar ulang sendiri
Hal terakhir yang akan kita lalui di bagian ini adalah touch_began (dan juga touch_moved dan touch_ended). Mudah ditebak, metode ini menangkap klik di layar. Mari kita coba:
class Game(Scene): def touch_began(self, touch): mypath = ui.Path.oval(0, 0, 50, 50) obj = ShapeNode(mypath) obj.color = (0.5, 0.5, 1.0) self.add_child(obj) obj.position = touch.location
Setiap kali Anda mengklik pada layar, kami membuat lingkaran, tempat klik adalah touch.location.
Siap menulis ular
Mekanisme permainanSeekor ular adalah deretan kotak, ketika kepala bergerak - potongan kedua bergerak ke tempat yang pertama, yang ketiga ke tempat yang kedua, dll. Untuk mengetahui persimpangan kepala dengan ekor, kita akan membandingkannya dengan setiap potongan ekor
Kami menghapus semua kode tertulis, karena kami ingin melakukannya dengan lebih atau kurang indah (tetapi, tentu saja, kami akan melakukan sepeda).
Pertama, mari kita buat kelas PhyObj:
class PhyObj: def __init__(self, path, color, parent): self.graph_obj = ShapeNode(path, parent=parent) self.parent = parent self.graph_obj.color = color def setpos(self, x, y): self.graph_obj.position = (x, y) def getpos(self): return self.graph_obj.position def move(self, x, y): self.graph_obj.position += (x, y)
Saya pikir semuanya sepele di sini. Di dalam kelas itu sendiri, kami membuat simpul, dan juga menjelaskan beberapa metode yang akan membuat kode kami lebih mudah dibaca.
HolivarySecara pribadi, saya lebih suka membuat kelas tingkat rendah yang memiliki banyak metode dan properti duplikat, tetapi kemudian kode di tingkat yang lebih tinggi menjadi sangat indah dan mudah dibaca.
PhyObj adalah objek level terendah dalam game kami, bahkan itu adalah objek fisik abstrak.
Deskripsi ular
Sekarang kita perlu menggambarkan ular itu, dan karena itu terdiri dari potongan-potongan, pertama-tama kita akan menggambarkan satu:
class Tile(PhyObj): def __init__(self, parent, size, margin=4): super().__init__(ui.Path.rect(0, 0, size[0] - margin, size[1] - margin), "#66FF66", parent) def die(self): self.graph_obj.color = "red"
Dalam konstruktor, kita memanggil metode induk kelas dan memberi diri kita bentuk dan warna. margin diperlukan agar kotak tidak saling menempel dan membuat semacam jaring.
class Game(Scene): def setup(self): self.tile = Tile(self, (40, 40)) self.tile.setpos(100, 100)
Seharusnya berubah:
Tapi misalnya, mengapa kita perlu margin:
class Game(Scene): def setup(self): tile1 = Tile(self, (40, 40)) tile1.setpos(100, 100) tile2 = Tile(self, (40, 40)) tile2.setpos(140, 100)
Nah, sekarang dari potongan-potongan ini Anda perlu lem ular. Kami membutuhkan metode inisialisasi dan metode bergerak.
Pertama, buat inisialisasi:
class Snake: def __init__(self, length, width, initpos, parent): self.width = width
Mari kita coba menggambarnya segera:
class Game(Scene): def setup(self): self.snake = Snake(10, 40, (200, 200), self)
Nah, tambahkan metode pindah.
class Snake: def move(self, x, y): for i in range(len(self.tiles) - 1, 0, -1): self.tiles[i].setpos(*self.tiles[i - 1].getpos()) self.tiles[0].move(x * self.width, y * self.width)
Pertama kita memindahkan yang terakhir ke kedua dari belakang, lalu yang kedua dari belakang ke yang kedua ... kemudian yang kedua ke yang kedua. Dan yang pertama di (x, y).
Sebenarnya, ular kami bergerak dengan baik. Mari kita coba:
class Game(self):
Jika Anda berhasil melihat, maka dia merangkak pergi sebagaimana mestinya. Faktanya adalah bahwa pembaruan sangat sering dipanggil (dan omong-omong, secara opsional dengan interval yang sama), jadi kita perlu mempertimbangkan berapa banyak waktu yang telah berlalu sejak panggilan terakhir dan menunggu sampai "cukup" terakumulasi.
Singkatnya, kami melakukan:
class Game(Scene): def time_reset(self): self.last_time = self.t def time_gone(self, t): if self.t - self.last_time > t: res = True self.time_reset() else: res = False return res def setup(self): self.snake = Snake(10, 40, (200, 200), self) self.time_reset() def update(self): if self.time_gone(0.3): self.snake.move(0, 1)
time_gone mengembalikan True jika lebih banyak waktu telah berlalu daripada t. Sekarang ular akan bergerak setiap 0,3 detik. Apakah itu berhasil?
Manajemen
Sekarang Anda perlu melakukan kontrol, yaitu, belokan di keempat arah:
class Game(Scene):
Dan sekarang kita perlu melakukan proses touch_began untuk memahami area yang ditusuk pengguna. Sebenarnya, ternyata tidak semenarik yang saya kira, jadi di sini Anda cukup menyalin:
class Game(Scene):
Nah, coba balik sekarang
Mekanisme utama berhasil, masih harus melakukan pemeriksaan untuk tabrakan dan apel.
Tabrakan ekor
Mari kita mulai dengan memeriksa dan menambahkan metode find_collisions ke ular
class Snake:
Sekarang kita bisa mendapatkan sepasang sel yang berpotongan. Saya ingin warna mereka merah, tambahkan metode die ke Tile:
class Tile(PhyObj):
Tambahkan cek untuk memperbarui dan mengubah pengaturan:
class Game(Scene):
Apa yang terjadi pada saya:
Masih membuat apel.
Perpanjangan dan apel
Kami akan memperpanjang ular itu, dan agar terlihat indah, tautan baru akan ditambahkan sesuai dengan dua yang terakhir, yaitu:
Tambahkan metode ke ular:
class Snake:
find_dir menemukan arah di mana ujung ekor pahlawan kita diarahkan. tambahkan, mudah ditebak, menambahkan sel. Tambahkan metode snake_lengthen lain ke Game:
class Game(Scene):
Baris terakhir diperlukan agar ular menunggu sedikit, dan pengguna punya waktu untuk melihat bahwa potongan telah ditambahkan.
Untuk mengetahui apakah ada sesuatu yang bersilangan dengan ular, tambahkan metode perpotongan padanya.
class Snake:
Hore, tetap hanya untuk membuat apel. Sebenarnya, kami menggambarkan apel dalam sekali jalan:
class Apple(PhyObj): def __init__(self, width, size, parent): super().__init__(ui.Path.oval(0, 0, size[0], size[1]), "#55AAFF", parent) self.parent = parent self.width = width self.dislocate() def dislocate(self): a = random.randint(2, int(self.parent.size.w / self.width) - 2) b = random.randint(2, int(self.parent.size.h / self.width) - 2) self.setpos(a * self.width, b * self.width)
Keacakan yang aneh seperti itu diperlukan agar sesuai dengan mata banteng kita di grid. Maka tidak perlu mencari jarak antara moncong dan apel dan membandingkan pyre-pyr-nya. Hanya di ifas. Mari kita perbarui dan tambahkan baris yang sangat sederhana ke akhir fungsi ini:
class Game(Scene):
Nah, semuanya tampaknya, sekarang ular memanjang jika menabrak apel dan mati jika menabrak dirinya sendiri.
Bonus
Anda dapat membuat efek suara:
import sound class Game(Scene):
Lakukan gerakan halus:
class Game(Scene):
Dengan kata lain, kami mengubah logika posisi PhyObj. Sebelumnya, kami fokus pada posisi elemen grafis, dan sekarang ada bidang terpisah untuk posisi logis (yaitu, yang digunakan untuk logika permainan), dan posisi elemen grafis sekarang bebas dan entah bagaimana dapat diubah dengan caranya sendiri. Yaitu, menggunakan Action, kami meninggalkannya aliran paralel, di mana dia bergerak.
Ternyata ular yang begitu halus:
Dan akhirnya, label dengan panjang ular:
class Game(Scene):
Teman-teman, terima kasih atas perhatian Anda! Jika ada sesuatu yang tidak jelas, tanyakan. Dan jika itu akan menarik - saya akan melanjutkan, masih ada sesuatu untuk diceritakan (tetapi artikel ini sudah agak panjang).
Semua kode ular from scene import * import random import math import sound class PhyObj: def __init__(self, path, color, parent): self.graph_obj = ShapeNode(path, parent=parent) self.parent = parent self.graph_obj.color = color self.pos = self.graph_obj.position def setpos(self, x, y, t=0.0): self.pos = (x, y) self.graph_obj.run_action(Action.move_to(x, y, t)) def getpos(self): return self.pos def move(self, x, y, t=0.0): self.pos = (self.pos[0] + x, self.pos[1] + y) self.graph_obj.run_action(Action.move_by(x, y, t)) class Tile(PhyObj): def __init__(self, parent, size, margin=4): super().__init__(ui.Path.rect(0, 0, size[0] - margin, size[1] - margin), "#66FF66", parent) def die(self): self.graph_obj.color = "red" class Snake: def __init__(self, length, width, initpos, parent): self.width = width self.tiles = [Tile(parent, (width, width)) for i in range(length)] for i, tile in enumerate(self.tiles): tile.setpos(initpos[0] + i * self.width, initpos[1]) self.parent = parent def move(self, x, y): for i in range(len(self.tiles) - 1, 0, -1): self.tiles[i].setpos(*self.tiles[i - 1].getpos(), self.parent.GLOBAL_TIMING) self.tiles[0].move(x * self.width, y * self.width, self.parent.GLOBAL_TIMING) def find_collisions(self): for i in range(1, len(self.tiles)): if self.tiles[i].getpos() == self.tiles[0].getpos(): return self.tiles[i], self.tiles[0] return False def find_dir(self, x1, y1, x2, y2): if x1 == x2 and y1 > y2: return (0, 1) elif x1 == x2 and y1 < y2: return (0, -1) elif y1 == y2 and x1 > x2: return (1, 0) elif y1 == y2 and x1 < x2: return (-1, 0) else: assert False, "Error!" def append(self): if len(self.tiles) > 1: lastdir = self.find_dir(*self.tiles[-1].getpos(), *self.tiles[-2].getpos()) else: lastdir = (-self.parent.dir[0], -self.parent.dir[1]) self.tiles.append(Tile(self.parent, (self.width, self.width))) x_prev, y_prev = self.tiles[-2].getpos() self.tiles[-1].setpos(x_prev + lastdir[0] * self.width, y_prev + lastdir[1] * self.width) def getpos(self): return self.tiles[0].getpos() def intersect(self, x, y): return self.getpos() == (x, y) class Apple(PhyObj): def __init__(self, width, size, parent): super().__init__(ui.Path.oval(0, 0, size[0], size[1]), "#55AAFF", parent) self.parent = parent self.width = width self.dislocate() def dislocate(self): a = random.randint(2, int(self.parent.size.w / self.width) - 2) b = random.randint(2, int(self.parent.size.h / self.width) - 2) self.setpos(a * self.width, b * self.width) class Game(Scene): def snake_lengthen(self): self.snake.append() self.time_reset() sound.play_effect('arcade:Powerup_1', 0.25, 0.8) def time_reset(self): self.last_time = self.t def time_gone(self, t): if self.t - self.last_time > t: res = True self.time_reset() else: res = False return res def setup(self): self.game_on = False self.GLOBAL_TIMING = 0.2 self.GLOBAL_WIDTH = 40 self.apple = Apple(self.GLOBAL_WIDTH, (50, 50), self) self.snake = Snake(30, self.GLOBAL_WIDTH, (200, 200), self) self.time_reset() self.dir = (0, 1) self.label = LabelNode("", font=("Chalkduster", 20), parent=self, position=(self.size.w / 2, self.size.h - 100)) self.update_labels() self.game_on = True def update_labels(self): self.label.text = "Length: " + str(len(self.snake.tiles)) def update(self): if not self.game_on: return col = self.snake.find_collisions() if col: for tile in col: tile.die() self.game_on = False if self.time_gone(self.GLOBAL_TIMING): self.snake.move(*self.dir) if self.snake.intersect(*self.apple.getpos()): self.snake_lengthen() self.apple.dislocate() self.update_labels() def touch_began(self, touch): ws = touch.location[0] / self.size.w hs = touch.location[1] / self.size.h aws = 1 - ws if ws > hs and aws > hs: self.dir = (0, -1) elif ws > hs and aws <= hs: self.dir = (1, 0) elif ws <= hs and aws > hs: self.dir = (-1, 0) else: self.dir = (0, 1) run(Game(), LANDSCAPE)
Kode kristal Edisi WhiteBlackGooseSangat lucu bahwa setelah saya membuatnya, saya menemukan sesuatu yang SANGAT mirip dalam contoh-contoh dari pythonista itu sendiri. Tapi saya punya lebih banyak fitur :)
from scene import * from math import pi from random import uniform as rnd, choice, randint import sys import random A = Action sys.setrecursionlimit(1000000) colors = ['pzl:Green5', "pzl:Red5", "pzl:Blue5"] + ["pzl:Purple5", "pzl:Button2"] + ["plf:Item_CoinGold"] global inited inited = False class Explosion (Node): def __init__(self, brick, *args, **kwargs): Node.__init__(self, *args, **kwargs) self.position = brick.position for dx, dy in ((-1, -1), (1, -1), (-1, 1), (1, 1)): p = SpriteNode(brick.texture, scale=0.5, parent=self) p.position = brick.size.w/4 * dx, brick.size.h/4 * dy p.size = brick.size d = 0.6 r = 30 p.run_action(A.move_to(rnd(-r, r), rnd(-r, r), d)) p.run_action(A.scale_to(0, d)) p.run_action(A.rotate_to(rnd(-pi/2, pi/2), d)) self.run_action(A.sequence(A.wait(d), A.remove())) class Brick (SpriteNode): def __init__(self, brick_type, *args, **kwargs): img = colors[brick_type] SpriteNode.__init__(self, img, *args, **kwargs) self.brick_type = brick_type self.is_on = True self.lf = True self.enabled = True def destroy(self): self.remove_from_parent() self.is_on = False def mark(self): self.lf = False def demark(self): self.lf = True class Game(Scene): def brickgetpos(self, i, j): return (self.Woff + j * self.W, self.Hoff + i * self.H) def brick(self, ty, i, j): b = Brick(ty, size=(self.W, self.H), position=self.brickgetpos(i, j), parent=self.game_node) b.rotation = random.random() return b def random_brick_type(self): if random.random() < 0.992: return random.randint(0, 3) else: if random.random() < 0.8: return 5 else: return 4 def setup(self): FONT = ('Chalkduster', 20) self.score_label = LabelNode('Score: 0', font=FONT, position=(self.size.w/2-100, self.size.h-40), parent=self) self.score = 0 self.last_score_label = LabelNode('Delta: +0', font=FONT, position=(self.size.w/2-300, self.size.h-40), parent=self) self.last_score = 0
Demonstrasi karya kristal: