ИгрыХабрахабр

Написание змейки на ipad (pythonista)

… или как убить время имея ipad и больше ничего...

Привет!

О чем речь?

К сожалению, планшеты пока не заменяют компьютеры. Но покодить в поездке/полете это же жизненно необходимо. Поэтому я поискал какие ide есть под ipad, и собственно сегодня буду делать игрульку на Pythonista.

Что будем делать?

Простейшие программы, например кристаллики (да да, те самые, в которые вы играете в метро). Тетрис, змейка, fill — любой новичок, немного разобравшись, напишет их за 30 минут. Под катом — скриншоты, туториал, код.
Вот несколько скриншотов с того, что я наляпал:

Много скринов

Дисклеймер

А еще что-то стырено из примеров к pythonista и документации.
Эта статья не только исключительно для новичков (но знающих python) и не позволит создавать world of tanks за десять минут и вообще какое-либо готовое приложение, но и автор не ручается за абсолютно красивый и правильный код с точки зрения религии программирования (хотя старается).

Весь код будет приведен в конце

Познакомимся с графикой в pythonista

Импорт

from scene import *
import random

Сразу создадим сцену:

class Game(Scene): def setup(self): self.background_color = "green" run(Game(), LANDSCAPE)

Ну и сразу запустим. У вас должен был получиться зеленый экран. Давайте сделаем какую-нибудь классную штуку, добавив в класс Game метод update (который сам вызывается системой), а в него изменение цвета фона.

class Game(Scene): # Ранее описанные методы def update(self): self.background_color = (1.0, 1.0, (math.sin(self.t) + 1) / 2)

Теперь у нас экран плавно меняется с желтого на белый и обратно.

Создаем его также в методе setup: Теперь создадим какой-нибудь объект.


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" #А еще можно указывать как в html, например #FF00FF. Или в tuple, то есть (1.0, 0.0, 1.0). А еще в конец можно приписать alpha, то есть прозрачность self.add_child(self.obj) def update(self): self.obj.position = (500 + 200 * math.sin(self.t), 500 + 200 * math.cos(self.t))

Мы задали линию (mypath), создали по ней ShapeNode, указали ей цвет, а затем указали родителя (по сути одно и то же — указать родителя при создании, то есть ShapeNode(*..., parent=self) либо self.add_child(obj)).

Ну а в Game.update() мы меняем позицию объекта (tuple), причем оно в пикселях и считается от левого нижнего угла.

Объекты и ноды, родитель которого — сцена (или какой-то ее дочерний объект) перерисовываются сами
Заметьте, нам не нужно перерисовывать сцену (хотя можно).

Последнее, что мы пройдем в этом разделе — touch_began (а также touch_moved и touch_ended). Несложно догадаться, метод ловит нажатия на экран. Давайте опробуем:

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

При каждом нажатии на экран мы создаем кружочек, место клика — touch.location.

Готовы писать змейку

Механизм игры

д. Змейка — массив квадратиков, когда двигается голова — второй кусочек пододвигается на место первого, третий — на место второго и т. Чтобы узнать пересечение головы с хвостом, мы будем сравнивать ее с каждым кусочком хвоста

Убираем весь написанный код, потому что хотим сделать более менее красиво (но, разумеется, делать будем велосипеды).

Для начала давайте создадим класс 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)

Думаю, тут все тривиально. Внутри самого класса мы создали ноду, а также описали некоторые методы, которые будут делать наш код более читаемым.

Холивары

Лично я предпочитаю сначала создавать низкоуровневые классы, у которых пусть будет много дублирующихся методов и свойств, зато потом уже код в высокоуровневых становится очень красивым и читаемым.

PhyObj — это самый низкоуровневый объект в нашей игре, по сути — это абстрактный физический объект.

Описание змейки

Теперь надо бы описать змейку, а так как она состоит из кусочков, опишем сначала один:


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"

В конструкторе мы вызываем метод родителя класса и придаем себе форму и цвет. margin нужен чтобы квадратики не слипались и создавали некоторую сеточку.

class Game(Scene): def setup(self): self.tile = Tile(self, (40, 40)) self.tile.setpos(100, 100)

Должно было получится:

А вот к примеру зачем нужен 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)

Нам понадобится метод инициализации и метод move. Отлично, теперь из этих кусочков надо склеить змею.

Для начала создадим инициализацию:


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]) #Ну а здесь мы ставим позицию каждой клетке

Давайте сразу попробуем ее нарисовать:

class Game(Scene): def setup(self): self.snake = Snake(10, 40, (200, 200), self)

Ну и добавим метод move.

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)

Сначала двигаем последнюю к предпоследней, потом предпоследнюю к предпредпоследней… потом вторую к первой. А первую на (x, y).

Попробуем: Собственно, змейка у нас двигается прям хорошо.

class Game(self):
# <...> def update(self): self.snake.move(0, 1)

Если вы успели увидеть, то уползла она как надо. Дело в том, что update вызывается очень часто (и кстати необязательно с одинаковым интервалом), поэтому нам нужно считать, сколько времени прошло с последнего вызова и ждать, пока его «накопится» достаточно.

Короче, делаем:

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 возвращает True, если прошло больше времени, чем t. Теперь змейка будет передвигаться каждые 0.3 секунды. Получилось?

Управление

Теперь нужно сделать управление, то есть поворот во все четыре стороны:

class Game(Scene):
# <...> def setup(self): # <...> self.dir = (0, 1) # это направление по умолчанию def update(self): if self.time_gone(0.3): self.snake.move(*self.dir)

А теперь надо сделать обработку touch_began, чтобы понять в какую область ткнул юзер. На самом деле это оказалось не так интересно, как я думал, поэтому тут можно просто скопировать:

class Game(Scene):
# <...> 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)

Ну вот, попробуйте теперь поворачивать

Основной механизм проработан, осталось сделать проверку на столкновения и яблочки.

Столкновение с хвостом

Начнем с проверки и добавим в змейку метод find_collisions

class Snake:
# <...> 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

Теперь мы можем получить пару клеток, которые пересеклись. Хотелось бы покрасить их в красный, добавим метод die в Tile:

class Tile(PhyObj):
# <...> def die(self): self.graph_obj.color = "red"

Добавим проверку в update и изменим setup:

class Game(Scene):
# <...> def setup(self): self.snake = Snake(30, 40, (200, 200), self) # Создаем змейку self.time_reset() self.dir = (0, 1) self.game_on = True #А запущена ли игра? 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(0.3): self.snake.move(*self.dir)

Что получилось у меня:

Осталось сделать яблочки.

Удлинение и яблочки

Сделаем удлинение змейки, причем чтобы оно выглядело красиво, новое звено будет добавлено в соответствии с последними двумя, то есть:

Добавим в змею методы:

class Snake:
# <...> 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)

find_dir находит направление, в которое направлен кончик хвоста нашей героини. append, несложно догадаться, добавляет ячейку. Добавим еще метод snake_lengthen в Game:


class Game(Scene):
# <...> def snake_lengthen(self): self.snake.append() self.time_reset()

Последняя строка нужна чтобы змейка немножко подождала, а пользователь успел увидеть, что кусочек добавился.

Чтобы узнать пересекается ли что-то со змеей, добавим в нее метод intersect

class Snake:
# <...> 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)

Такой странный рандом нужен чтобы уместить наше яблочко по сетке. Тогда не нужно будет искать расстояние между мордой и яблоком и сравнивать его тыры-пыры. Просто на ифах. Пойдем в update и добавим в конец этой функции очень простые строки:

class Game(Scene):
# <...> def setup(self): self.apple = Apple(40, (50, 50), self) #Число 40 - ширина сетки, должно совпадать с вторым аргументом в Snake() # <...> def update(self): # <...> if self.snake.intersect(*self.apple.getpos()): self.snake_lengthen() self.apple.dislocate()

Ну вроде все, теперь змея удлиняется если попадает в яблоко и умирает, если стукается сама о себя.

Бонус

Можно сделать звуковые эффекты:

import sound class Game(Scene):
# <...> def snake_lengthen(self): self.snake.append() self.time_reset() sound.play_effect('arcade:Powerup_1', 0.25, 0.8)

Сделать плавное движение:

class Game(Scene):
# <...> 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(10, self.GLOBAL_WIDTH, (200, 200), self) self.time_reset() self.dir = (0, 1) self.game_on = True 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.parent.GLOBAL_TIMING) self.tiles[0].move(x * self.width, y * self.width, self.parent.GLOBAL_TIMING) 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)) # Плавное движение к 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))

Иначе говоря, мы изменили логику position PhyObj. Раньше мы ориентировались на позицию графического элемента, а теперь есть отдельное поле логической позиции (то есть той, что используется для логики игры), и позиция графического элемента теперь свободна и может быть как-то изменена по-своему. А именно, используя Action, мы оставляем ей параллельный поток, где она и двигается.

Такая плавная змея получилась:

Ну и наконец label с длиной змеи:

class Game(Scene):
# <...> 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() #Обновляем тут

Если что-то непонятно, спрашивайте. Друзья, спасибо за внимание! А если будет интересно — продолжу, еще есть что рассказать (но эта статейка и так длинновата).

Весь код змейки


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)

Код кристалликов WhiteBlackGoose edition

Забавно, что после того, как я ее сделал, я обнаружил что-то ОЧЕНЬ похожее в примерах из самой pythonista. Но у меня чуть больше фич 🙂


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 #self.avg_label = LabelNode('Speed: +0/s', font=FONT, position=(self.size.w/2+100, self.size.h-40), parent=self) #self.max_label = LabelNode('Peak: +0/s', font=FONT, position=(self.size.w/2+300, self.size.h-40), parent=self) #self.max_speed = 0 self.game_time = 120 self.timel = LabelNode('Time: ' + str(self.game_time) + "s", font=FONT, position=(self.size.w/2+300, self.size.h-40), parent=self) self.gems = [0 for i in colors] self.effect_node = EffectNode(parent=self) self.game_node = Node(parent=self.effect_node) self.l = [0 for i in colors] self.lt = [0 for i in colors] for i in range(len(colors)): R = 50 if i == 6 else 35 self.l[i] = Brick(i, size=(R, R), position=(40, self.size.h-100-i*40), parent=self.game_node) self.lt[i] = LabelNode(": 0", font=FONT, position=(self.l[i].position[0] + 40, self.l[i].position[1]), parent=self) self.WB = 30 self.HB = 30 self.W = 900 // self.WB self.H = 900 // self.HB self.colcount = 4 self.Woff = (int(self.size.w) - self.W * self.WB + self.W) // 2 self.Hoff = self.H + 10 self.net = [[self.brick(self.random_brick_type(), i, j) for i in range(self.HB)] for j in range(self.WB)] #self.touch_moved = self.touch_began self.start_time = self.t self.game_on = True global inited inited = True def demark(self): for bricks in self.net: for brick in bricks: brick.demark() def howfar(self, x, y): alt = 0 for i in range(y): if not self.net[x][i].is_on: alt += 1 return alt def update(self): global inited if not inited: return self.game_on = self.t - self.start_time < self.game_time if self.game_on: self.timel.text = "Time: " + str(round(self.game_time - (self.t - self.start_time))) + "s" else: self.timel.text = "Game over" #if speed > self.max_speed: # self.max_speed = speed # self.max_label.text = "Peak: +" + str(round(self.max_speed)) + "/s" def gravity(self, x, y): alt = self.howfar(x, y) if alt == 0: return self.net[x][y].destroy() self.net[x][y - alt] = self.brick(self.net[x][y].brick_type, y, x) self.net[x][y - alt].position = self.net[x][y].position self.net[x][y - alt].rotation = self.net[x][y].rotation self.net[x][y - alt].enabled = False self.net[x][y - alt].run_action(A.sequence(A.move_to(*self.brickgetpos(y - alt, x), 0.2 * alt ** 0.5, TIMING_EASE_IN_2), A.call(lambda: self.enable_cell(x, y - alt)))) def enable_cell(self, x, y): self.net[x][y].enabled = True def fall(self): for x in range(self.WB): for y in range(self.HB): if self.net[x][y].is_on: self.gravity(x, y) def update_scores(self): self.score += self.last_score self.score_label.text = "Score: " + str(self.score) self.last_score_label.text = "Delta: +" + str(self.last_score) self.last_score = 0 def update_cells(self): for i in range(self.WB): for j in range(self.HB): if not self.net[i][j].is_on: self.net[i][j] = self.brick(self.random_brick_type(), j + self.HB, i) self.net[i][j].enabled = True self.net[i][j].run_action(A.sequence(A.move_to(*self.brickgetpos(j, i), 0.2 * self.HB ** 0.5, TIMING_EASE_IN_2), A.call(lambda: self.enable_cell(i, j)))) def inbounds(self, x, y): return (x >= 0) and (y >= 0) and (x < self.WB) and (y < self.HB) def bomb(self, x, y, radius): score = 0 bc = 0 for i in range(round(4 * radius ** 2)): rad = random.random() * radius ang = random.random() * 2 * pi xp, yp = x + sin(ang) * rad, y + cos(ang) * rad xp, yp = int(xp), int(yp) if self.inbounds(xp, yp): score += self.explode(xp, yp) self.fall() self.give_score(round(score / 1.7), self.brickgetpos(y, x)) def laser(self, x, y): score = 0 coords = [] for i in range(self.HB): for j in range(-1, 1 + 1, 1): coords.append((x + j, i)) for i in range(self.WB): coords.append((i, y)) for i in range(-self.HB, self.HB): coords.append((x + i, y + i)) for i in range(-self.WB, self.WB): coords.append((x - i, y + i)) bc = 0 for x, y in coords: if not self.inbounds(x, y): continue score += self.explode(x, y) self.fall() self.give_score(score, self.brickgetpos(y, x)) def getty(self, x, y): if not self.inbounds(x, y) or not self.net[x][y].is_on: return -1 else: return self.net[x][y].brick_type def popupt(self, text, position_, font_=("Arial", 30), color_="white"): label = LabelNode(text, font=font_, color=color_, parent=self, position=position_) label.run_action(A.sequence(A.wait(1), A.call(label.remove_from_parent))) def give_score(self, count, xy): self.last_score = int(count ** 2.5) size = 10 if self.last_score > 50000: size = 60 elif self.last_score > 20000: size = 40 elif self.last_score > 10000: size = 30 elif self.last_score > 5000: size = 25 elif self.last_score > 2000: size = 20 elif self.last_score > 1000: size = 15 if self.last_score > 0: self.popupt("+" + str(self.last_score), xy, font_=("Chalkduster", int(size * 1.5))) self.update_scores() def touch_began(self, touch): if not self.game_on: return x, y = touch.location x, y = x + self.W / 2, y + self.H / 2 W, H = get_screen_size() x, y = x, y x, y = int(x), int(y) x, y = x - self.Woff, y - self.Hoff x, y = x // self.W, y // self.H if not self.inbounds(x, y): return count = self.react(self.net[x][y].brick_type, x, y, True) self.demark() if self.getty(x, y) in [0, 1, 2, 3]: if count >= 2: self.react(self.net[x][y].brick_type, x, y) self.fall() self.give_score(count, touch.location) elif self.getty(x, y) == 4: self.bomb(x, y, 5 * count) elif self.getty(x, y) == 5: self.explode(x, y) self.fall() self.update_cells() def explode(self, x, y): if self.net[x][y].is_on: self.net[x][y].destroy() self.gems[self.net[x][y].brick_type] += 1 s = str(self.gems[self.net[x][y].brick_type]) self.lt[self.net[x][y].brick_type].text = " " * len(s) + ": " + s self.game_node.add_child(Explosion(self.net[x][y])) return True else: return False def react(self, col, x, y, ignore=False): if self.inbounds(x, y) and self.net[x][y].brick_type == col and self.net[x][y].is_on and self.net[x][y].lf and self.net[x][y].enabled: if not ignore: self.explode(x, y) else: self.net[x][y].mark() r = 1 r += self.react(col, x + 1, y + 0, ignore) r += self.react(col, x - 1, y - 0, ignore) r += self.react(col, x + 0, y + 1, ignore) r += self.react(col, x - 0, y - 1, ignore) return r else: return 0 def destroy_brick(self, x, y): self.net[x][y].destroy() run(Game(), LANDSCAPE, show_fps=True)

Демонстрация работы кристалликов:

Теги
Показать больше

Похожие статьи

Добавить комментарий

Ваш e-mail не будет опубликован. Обязательные поля помечены *

Кнопка «Наверх»
Закрыть