def setup(self):
self.circle1 = scene.Rect(50, 50, 50, 50)
self.circle2 = scene.Rect(150, 50, 50, 50)
self.circle1_layer = scene.Layer(self.circle1)
circle1 = Image.new('RGBA', (101, 101))
draw1 = ImageDraw.Draw(circle1)
draw1.ellipse((0, 0, 100, 100), fill=(0, 255, 0, 255))
self.circle1_layer.image = scene.load_pil_image(circle1)
self.circle1_layer.animate('alpha',
0.0,
duration=1.0,
autoreverse=True,
repeat=3) # alpha animation
self.add_layer(self.circle1_layer) # touch handling
self.circle2_layer = scene.Layer(self.circle2)
circle2 = Image.new('RGBA', (101, 101))
draw2 = ImageDraw.Draw(circle2)
draw2.ellipse((0, 0, 100, 100), fill=(255, 0, 0, 255))
self.circle2_layer.image = scene.load_pil_image(circle2)
self.circle2_layer.animate('scale_x',
2.0,
duration=1.0,
autoreverse=True,
repeat=sys.maxint) # alpha animation
self.circle2_layer.animate('scale_y',
2.0,
duration=1.0,
autoreverse=True,
repeat=sys.maxint) # alpha animation
def setup(self):
self.rect1 = scene.Rect(50, 50, 50, 50)
self.rect2 = scene.Rect(150, 50, 50, 50)
self.rect1_layer = scene.Layer(self.rect1)
self.add_layer(self.rect1_layer)
self.rect2_layer = scene.Layer(self.rect2)
self.add_layer(self.rect2_layer)
def check_collision(self, position, size):
dino_rect = scene.Rect(*(position - self.position), *size)
for cactus in self.children:
cactus_rect = scene.Rect(*(cactus.left_buttom_coord), *cactus.size)
if dino_rect.intersects(cactus_rect):
return True
return False
def setup(self):
self.rect1 = scene.Rect(50, 50, 50, 50)
self.circle2 = scene.Rect(150, 50, 50, 50)
self.rect1_layer = scene.Layer(self.rect1)
self.rect1_layer.background = scene.Color(0, 1, 0)
self.rect1_layer.animate('alpha',
0.0,
duration=1.0,
autoreverse=True,
repeat=3) # alpha animation
self.add_layer(self.rect1_layer) # touch handling
self.circle2_layer = scene.Layer(self.circle2)
self.add_layer(self.circle2_layer)
def draw(self):
#self.prevmode = self.mode
self.mode = 'off'
for touch in touches:
if touch.location in scene.Rect(*self.rect):
self.mode = 'on'
#elif self.prevmode == 'on':
#self.mode = 'up'
# if self.mode == 'on':
# try:
# self.on()
# except AttributeError:
# pass
# elif self.mode == 'up':
# try:
# self.up()
# except AttributeError:
# pass
# else:
# try:
# self.off()
# except AttributeError:
# pass
try:
if self.mode == 'on':
self.on()
else:
self.off()
except AttributeError:
pass
def setup(self):
self.button_dict = collections.OrderedDict([
('+', self.increase_font_size), ('—', self.decrease_font_size),
('Font', self.next_font), ('Color', self.next_color),
('Save', self.save_image), ('Cancel', self.cancel)
])
fgColor = scene.Color(*color('black'))
bgColor = scene.Color(*color('grey'))
loc = [0, 0]
for button_text in self.button_dict:
if button_text == '+':
button_text = ' + ' # double spaces around '+'
else: # single space around others
button_text = ' ' + button_text + ' '
theButton = TextButton(self, loc, button_text, fgColor, bgColor)
self.btn_height = max(self.btn_height, theButton.frame.h)
loc[0] += theButton.frame.w + 4 # 4 pixels between each button
self.picratio = self.picsize.w / (self.picsize.h * 1.0)
usable_space = self.bounds.h - self.btn_height
x = usable_space * self.picratio
if x <= self.bounds.w:
y = usable_space
else:
x = self.bounds.w
y = self.bounds.w / self.picratio
self.position = scene.Size(x / 2, y / 2) # no ...y/2+self.btn_height
self.picscale = self.picsize[0] / (x * 1.0)
self.layer = scene.Layer(scene.Rect(0, self.btn_height, x, y))
self.layer.image = scene.load_pil_image(self.img)
self.add_layer(self.layer)
def setup(self):
(imageName, imageSize) = self.getImageNameAndSize()
theRect = scene.Rect(0, 0, *imageSize)
theRect.center(self.bounds.center())
print(theRect),
print(self.bounds)
self.add_layer(scene.Layer(theRect))
self.root_layer.image = imageName
def __init__(self, inFontName = 'Helvetica'): (imageName, imageSize) = scene.render_text(inFontName, font_name=inFontName, font_size=64) theRect = scene.Rect(0, 0, imageSize.w, imageSize.h) super(self.__class__, self).__init__(theRect) self.tint = colorLightBlue # self.background = colorWhite # useful for debugging self.image = imageName self.dx = 1 self.dy = 1
def setup(self):
# Setup screen with top 200 pixels reserved for text
w = self.col_width = self.size.w / 4
h = self.row_height = (self.size.h - 200) / 4
for animal in animals:
layer = scene.Layer(scene.Rect(0, 0, w, h))
layer.image = animal
self.add_layer(layer)
self.shuffle_layer_locations()
self.current_animal = self.different_layer()
def __init__(self, inScene, inLoc, inText, inFgColor, inBgColor):
(theImage, theSize) = scene.render_text(inText, font_size=48)
super(self.__class__,
self).__init__(scene.Rect(inLoc[0], inLoc[1], *theSize))
inScene.add_layer(self)
self.parent = inScene
self.text = inText.strip()
self.image = theImage
self.stroke = inFgColor # border color
self.stroke_weight = 2 # border width
self.background = inBgColor
def touch_began(self, touch):
w, h = self.button_size.x, self.button_size.y
for button in self.buttons:
name, title, value, position, action = button
hit_test = scene.Rect(position.x, position.y, w, h)
if touch.location in hit_test:
if action: # toggles have action == None
action()
else:
self.toggle(name)
self.sync_data()
break
def check_fall_off(self):
# If the player is at the bottom of the jump, see if the block frame intersects the player hitbox
if self.count % len(self.jump) == 0:
player_hitbox = sc.Rect(self.player.position.x - 20,
self.player.position.y - 5, 40, 65)
block = self.current_block
if block.frame.intersects(player_hitbox):
fall = False
else:
fall = True
self.run_action(sc.Action.call(self.player_dead))
def check_jump(self):
# Define a player hitbox as a rectangle around the player
player_hitbox = sc.Rect(self.player.position.x - 20,
self.player.position.y, 40, 65)
# Iterate over blocks in the game
for block in list(self.blocks):
# check if the block position overlaps with the player, while the player is falling
if self.vel + np.round(
32 + block.position.y, 0
) > self.player.position.y and np.round(
32 + block.position.y, 0
) - self.vel < self.player.position.y and block.frame.intersects(
player_hitbox) and self.jump[self.count %
len(self.jump)] < 0:
# if the condition is satisfied, the player has performed a succesful jump. The camera view should now be shifted. This can be done by moving all in-game blocks by the distance of the jump
for b in list(self.blocks):
b.run_action(
sc.Action.move_by(0, -block.position.y, 0.5,
sc.TIMING_SINODIAL))
# Additionally, if blocks have moved below the current camera view, they should be removed from the game
if b.position.y < 0:
b.remove_from_parent()
b.run_action(sc.Action.remove())
self.blocks.remove(b)
# Reset the counter to 1 and the player position to 32 (corresponds to the start of a new jump)
self.count = -1
self.player.position.y = 32
# Change the moving function to True to ensure that a correct, modified jump mechanics are applied
self.moving = True
# Make sure that the ground is removed from the game
self.ground.run_action(sc.Action.remove())
# Define the block the player is currently standing on
self.current_block = block
self.jumped = True
self.player.texture = landing_texture
# Increment the score by the normalised jump distance
self.score += int(np.round(block.position.y / 10, 0))
self.score_label.text = str(self.score)
self.high_score_val = max(self.score, self.high_score_val)
self.high_score.text = str(self.high_score_val)
def setup(self):
self.center = self.bounds.center()
pad = 4 # pixels between buttons
loc = scene.Point(pad, pad)
keyboard = make_keyboards()[0]
for keyrow in keyboard:
button_height = loc.x = pad
for key in keyrow:
width = 740 if key == 'space' else 89
key_button = TextButton(self, scene.Rect(loc[0], loc[1], width, 40), key)
loc.x += key_button.frame.w + pad
button_height = max(button_height, key_button.frame.h)
loc.y += button_height + pad
self.center.y += loc.y / 2 # move center up to compensate for keyboard
def setup(self):
# Determine which pawn is being promoted and set up the options
board = self.game_view.game.board
self.turn = board.turn
for p in board.pieces:
if p.is_promotable:
self.promoter = p
self.color = p.color # this syntax is a bit mind numbing
if not hasattr(self, 'promoter'):
del self # ???
#self.parent.switch_scene(self.game.data['screen_main'])
self.owner = self.promoter.owner
y = 7 if self.color == 'white' else 0
self.spawncoord = Coord(self.promoter.coord.x, y)
qpos, rpos, bpos, kpos = [Coord(x, 4) for x in (2, 3, 4, 5)]
self.queen = Queen(qpos, self.color, self.promoter.owner)
self.rook = Rook(rpos, self.color, self.promoter.owner)
self.bishop = Bishop(bpos, self.color, self.promoter.owner)
self.knight = Knight(kpos, self.color, self.promoter.owner)
self.pieces = [self.queen, self.rook, self.bishop, self.knight]
self.qrect = scene.Rect(self.queen.coord.as_screen.x,
self.queen.coord.as_screen.y, scale_factor,
scale_factor)
self.rrect = scene.Rect(self.rook.coord.as_screen.x,
self.rook.coord.as_screen.y, scale_factor,
scale_factor)
self.brect = scene.Rect(self.bishop.coord.as_screen.x,
self.bishop.coord.as_screen.y, scale_factor,
scale_factor)
self.krect = scene.Rect(self.knight.coord.as_screen.x,
self.knight.coord.as_screen.y, scale_factor,
scale_factor)
piece_types = [p.ptype for p in self.pieces]
self.img_names = self.game_view.load_images(piece_types)
def check_item_collisions(self):
# Define a player hitbox as a rectangle around the player
player_hitbox = sc.Rect(self.player.position.x - 20,
self.player.position.y, 40, 65)
# for each item in the game check if the item intersects the hitbox. Run the collection function if appropriate
for item in list(self.items):
if isinstance(item, Coin):
if item.frame.intersects(player_hitbox):
self.collect_item(item)
# When a coin has finished its animation, it is automatically removed from the scene by its Action sequence. When that's the case, also remove it from the `items` list, so it isn't checked for collisions anymore:
elif not item.parent:
self.items.remove(item)
if isinstance(item, Monster):
if item.frame.intersects(player_hitbox):
self.player_dead()
def __init__(self, screen, w, h):
self.size = scene.Size(w, h)
w, h = (screen.w / w, screen.h / h)
self.cells = {(x, y): Cell(x, y, scene.Rect(x * w, y * h, w, h))
for x in xrange(self.size.w)
for y in xrange(self.size.h)}
grid_img = Image.new('RGBA', [int(i) for i in screen.as_tuple()])
grid_draw = ImageDraw.Draw(grid_img)
for x in xrange(self.size.w):
grid_draw.line((x * w, 0, x * w, screen.h))
x = self.size.w
grid_draw.line((x * w - 1, 0, x * w - 1, screen.h))
for y in xrange(self.size.h):
grid_draw.line((0, y * h, screen.w, y * h))
y = self.size.h
grid_draw.line((0, y * h - 1, screen.w, y * h - 1))
self.grid_img = scene.load_pil_image(grid_img)
del grid_img, grid_draw
def __init__(self, *args, **kwargs):
w = scene.get_screen_size().w * 0.8
h = scene.get_screen_size().h * 0.25
path = ui.Path.rounded_rect(0, 0, w, h, 10)
path.line_width = 8
scene.ShapeNode.__init__(self,
path=path,
fill_color='#CDC1B4',
stroke_color='#BBADA0',
*args,
**kwargs)
board = self.parent.board
box = scene.Rect(board.bbox.x, board.bbox.y + board.bbox.h,
board.bbox.w, self.parent.size.h - board.bbox.h)
self.position = box.center()
self.score = 0
self.highscore = dict()
self.load_highscore()
self.score_label = self.create_score_label()
self.highscore_label = self.create_highscore_label()
self.create_title_label()
self.player_label = self.create_player_label()
def draw(self):
self.prevmode = self.mode
self.mode = 'off'
for touch in touches:
if touch.location in scene.Rect(*self.rect):
self.mode = 'on'
elif self.prevmode == 'on':
self.mode = 'up'
if self.mode == 'on':
scene.fill(*self.altcolor)
scene.tint(*self.alttxtcolor)
scene.stroke(*self.altbordrcolor)
else:
scene.fill(*self.color)
scene.tint(*self.txtcolor)
scene.stroke(*self.bordrcolor)
scene.stroke_weight(self.bordrw)
scene.rect(*self.rect)
scene.text(self.text, self.font, self.fontsize,
self.rect[0] + self.rect[2] / 2,
self.rect[1] + self.rect[3] / 2)
def __init__(self, x, y, w, h):
self.rect = scene.Rect(x, y, w, h)
self.colors = [(0, 0, 0, 0)]
def __init__(self, frame=None, velocity=None, color=None):
self.frame = frame or scene.Rect(0, 0, 25, 25)
self.velocity = velocity or scene.Point(0, 0)
self.color = color or random_color()
def __init__(self, x, y, w, h):
self.rect = scene.Rect(x, y, w, h) # Important: (x,y) is the lower-left corner
self.color = (0, 0, 0, 0)
self.index = 0 # Used to find neighbors
self.position = (x,y) # Used when writing images
# https://forum.omz-software.com/topic/3268/pythonista-3-rect-attributes/2 import scene, ui print(scene.Rect() == ui.Rect()) # True print(scene.Rect == ui.Rect) # True print(scene.Rect is ui.Rect) # True
def __init__(self, inImageName):
theRect = scene.Rect(0, 0, imageWidth, imageWidth)
scene.Layer.__init__(self, theRect)
self.dx = self.dy = 2 # Initial direction: upperRight
self.image = scene.load_image_file(inImageName)
def __init__(self, x, y):
self.bounds = scene.Rect(x, y, 80, 80)
def __init__(self):
theImage = diagonalLineImage()
theRect = scene.Rect(0, 0, *theImage.size)
super(self.__class__, self).__init__(theRect)
self.image = scene.load_pil_image(theImage)
def make_player(self):
player_size = 35
frame = scene.Rect(0, (self.bounds.h - player_size) / 2, player_size,
player_size)
color = scene.Color(1, 1, 1)
return Particle(frame=frame, color=color)
def setup(self):
x, y = self.bounds.center()
self.add_layer(Circle(scene.Rect(x - 150, y - 150, 100, 100)))
self.add_layer(Square(scene.Rect(x + 50, y + 50, 100, 100)))
def setup(self):
w, h = self.picsize
self.textPosition = scene.Size(w/2/self.scale, h/2/self.scale)
self.layer = scene.Layer(scene.Rect(0, 0, w/2, h/2))
self.layer.image = scene.load_pil_image(self.img)
self.add_layer(self.layer)
def rectFromPt(inPoint): # returns a scene.Rect centered on inPoint half = sizeInPixels / 2 return scene.Rect(inPoint.x - half, inPoint.y - half, sizeInPixels, sizeInPixels)
