def __init__(self):
screen_w, screen_h = ui.get_screen_size()
ipad = min(screen_w, screen_h) >= 768
diameter = floor(min(screen_w, screen_h) * 0.9)
border = 20.0 if ipad else 12.0
font_size = 70.0 if ipad else 32.0
face_img = self.draw_face(diameter, border, font_size)
self.face_sprite = sk.SpriteNode(sk.Texture(face_img))
self.face_sprite.position = self.size[0] / 2, self.size[1] / 2
self.add_child(self.face_sprite)
hand_length = diameter / 2 - font_size
hand_width = 15 if ipad else 12
second_hand_img = self.draw_hand(hand_width / 1.5, hand_length, 'red')
minute_hand_img = self.draw_hand(hand_width, hand_length, 'black')
hour_hand_img = self.draw_hand(hand_width, hand_length * 0.7, 'black')
self.second_hand_sprite = sk.SpriteNode(sk.Texture(second_hand_img))
self.second_hand_sprite.anchor_point = (0.5, 0.0)
self.minute_hand_sprite = sk.SpriteNode(sk.Texture(minute_hand_img))
self.minute_hand_sprite.anchor_point = (0.5, 0.0)
self.hour_hand_sprite = sk.SpriteNode(sk.Texture(hour_hand_img))
self.hour_hand_sprite.anchor_point = (0.5, 0.0)
self.face_sprite.add_child(self.hour_hand_sprite)
self.face_sprite.add_child(self.minute_hand_sprite)
self.face_sprite.add_child(self.second_hand_sprite)
self.center_sprite = sk.SpriteNode(
sk.Texture(self.draw_center(hand_width * 1.5, 'black')))
self.face_sprite.add_child(self.center_sprite)
def __init__(self):
self.dropped_sprites = set()
# Initialize the floor collision body:
w = self.size[0]
self.physics_body = sk.PhysicsBody.edge_loop_rect(0, -100, w, 100)
# Draw and cache textures for all numbers:
self.textures = {}
for n in '0123456789:':
w, h = s * 2 + 10, s * 2
with ui.ImageContext(w, h) as ctx:
ui.draw_string(n,
font=('AvenirNext-Regular', h * 0.94),
rect=(0, 0, w, h),
color='white',
alignment=ui.ALIGN_CENTER)
img = ctx.get_image()
self.textures[n] = sk.Texture(img)
margin = (self.size[0] - 7 * s) / 2
self.clock_nodes = []
self.time_str = time.strftime('%H:%M:%S')
# Create a sprite node for every character in the time string:
for i, c in enumerate(self.time_str):
sprite = sk.SpriteNode(self.textures[c])
sprite.position = i * s + margin, self.size[1] - 200
self.add_child(sprite)
self.clock_nodes.append(sprite)
def __init__(self, piece):
assert piece and isinstance(piece, ChessPiece)
sk.SpriteNode.__init__(self,
sk.Texture(C.image_path_fmt.format(piece.name)))
self.alpha = 0.5
self.piece = piece
self.size = piece_Size
self.touch_enabled = True
def __init__(self):
w, h = self.size
img = ui.Image.named('gradient.png')
self.sprite = sk.SpriteNode(sk.Texture(img))
self.sprite.position = w / 2, h / 2
self.sprite.size = w, h
with open('SimplexNoise.fsh') as f:
shader = sk.Shader(f.read())
self.sprite.shader = shader
self.add_child(self.sprite)
def __init__(self):
self.digit_textures = {
i: sk.Texture('plf:Hud' + str(i))
for i in xrange(10)
}
self.digits = [
sk.SpriteNode(self.digit_textures[0]) for i in xrange(5)
]
for i, digit in enumerate(self.digits):
digit.position = (i * 27, 0)
self.add_child(digit)
def __init__(self):
with open('words_en.data') as f:
self.words = marshal.load(f)
self.root = sk.Node()
self.add_child(self.root)
self.background_color = '#0b1d28'
textures = {}
for letter in letter_freq:
with ui.ImageContext(tile_size, tile_size) as ctx:
shadow = ui.Path.rounded_rect(2, 2, tile_size - 4,
tile_size - 4, 5)
ui.set_color('silver')
shadow.fill()
bg = ui.Path.rounded_rect(2, 2, tile_size - 4, tile_size - 8,
5)
ui.set_color('white')
bg.fill()
font = ('AvenirNext-Regular', font_size)
w, h = ui.measure_string(letter.upper(), font=font)
x, y = (tile_size - w) / 2, (tile_size - h) / 2
ui.draw_string(letter.upper(),
rect=(x, y, w, h),
font=font,
color='black')
textures[letter] = sk.Texture(ctx.get_image())
self.tile_textures = textures
self.tiles = [] #[[None]*rows for i in xrange(cols)]
for x, y in product(xrange(cols), xrange(rows)):
s = self.create_tile(x, y)
self.tiles.append(s)
self.root.add_child(s)
self.selected = []
self.touched_tile = None
self.score_label = sk.LabelNode()
self.score_label.font_name = 'AvenirNext-Regular'
self.score_label.font_size = 50
self.score_label.h_align = sk.H_ALIGN_CENTER
self.score_label.text = '0'
self.score = 0
self.add_child(self.score_label)
self.did_change_size(None)
def __init__(self):
with open('words_en.data') as f:
self.words = marshal.load(f)
self.root = sk.Node()
self.did_change_size(None)
self.add_child(self.root)
self.background_color = '#0b1d28'
textures = {}
for letter in letter_freq:
with ui.ImageContext(tile_size, tile_size) as ctx:
shadow = ui.Path.rounded_rect(0, 0, tile_size, tile_size, 5)
ui.set_color('silver')
shadow.fill()
bg = ui.Path.rounded_rect(0, 0, tile_size, tile_size - 4, 5)
ui.set_color('white')
bg.fill()
font = ('AvenirNext-Regular', font_size)
w, h = ui.measure_string(letter.upper(), font=font)
x, y = (tile_size - w) / 2, (tile_size - h) / 2
ui.draw_string(letter.upper(),
rect=(x, y, w, h),
font=font,
color='black')
textures[letter] = sk.Texture(ctx.get_image())
self.tile_textures = textures
self.tiles = [[None] * rows for i in xrange(cols)]
for x, y in product(xrange(cols), xrange(rows)):
letter = choice(letter_bag)
s = sk.SpriteNode(self.tile_textures[letter])
s.user_info = {'letter': letter, 'x': x, 'y': y}
pos_x = tile_size / 2 + x * (tile_size + padding)
pos_y = tile_size / 2 + y * (tile_size + padding)
if x % 2 != 0:
pos_y += tile_size / 2
s.position = pos_x, pos_y
s.color_blend_factor = 1
s.color = 'white'
self.tiles[x][y] = s
self.root.add_child(s)
self.selected = []
self.touched_tile = None
'''Multi-touch particle generator'''
import sk
texture = sk.Texture('shp:Spark')
# The birth rate determines how many particles are emitted per second - if the animation stutters on your device, try reducing this number, on the latest-generation hardware, you may be able to increase it:
birth_rate = 750
# Load the emitter 'template' from the scene file:
emitter_tpl = sk.load('ParticlePaint.pysk')['emitter'][0]
emitter_tpl.p_birth_rate = 0
class ParticleScene(sk.Scene):
def __init__(self):
self.emitters = {}
self.instructions = sk.LabelNode()
self.instructions.text = 'Touch to create particles.'
self.instructions.font_size = 30
self.instructions_visible = True
self.add_child(self.instructions)
self.did_change_size(None)
def did_change_size(self, old_size):
self.instructions.position = self.size.w / 2, self.size.h / 2
def touch_began(self, node, touch):
if self.instructions_visible:
self.instructions.run_action(sk.fade_out(2.0))
self.instructions_visible = False
e = emitter_tpl.__copy__()
# coding: utf-8
# (work-in-progress, but playable)
import sk
import sound
from itertools import chain
from random import choice
from functools import partial
import gc
import ui
zoom = 1.0 if max(ui.get_screen_size()) > 768 else 0.7
player_and_effects = sk.load('PlayerAndEffects.pysk', sk.Node())
star_effect = player_and_effects['stars'][0]
standing_texture = sk.Texture('plf:AlienPink_stand')
walk_textures = [
sk.Texture('plf:AlienPink_walk1'),
sk.Texture('plf:AlienPink_walk2')
]
jump_texture = sk.Texture('plf:AlienPink_jump')
hit_texture = sk.Texture('plf:AlienPink_hit')
spring_texture1 = sk.Texture('plf:Tile_Spring')
spring_texture2 = sk.Texture('plf:Tile_Sprung')
bg_texture = sk.Texture('plf:BG_Blue_grass')
sounds = {
'coin': 'digital:PowerUp2',
'star': 'digital:PowerUp7',
'jump': 'digital:PhaserUp2',
'spring': 'digital:PhaserUp3',
'die': 'digital:ZapThreeToneDown',
'jetpack': 'digital:LowRandom',
cols, rows = 10, 11
else:
cols, rows = 7, 7
tile_size = min_screen / (max(cols, rows) + 1)
font_size = int(tile_size * 0.7)
# Derived from http://en.m.wikipedia.org/wiki/Letter_frequency
letter_freq = {'a': 8.2, 'b': 1.5, 'c': 2.8, 'd': 4.3, 'e': 12.7, 'f': 2.3, 'g': 2.0, 'h': 6.1, 'i': 7.0, 'j': 0.2, 'k': 7.7, 'l': 4.0, 'm': 2.4, 'n': 6.7, 'o': 7.5, 'p': 1.9, 'q': 0.1, 'r': 6.0, 's': 6.3, 't': 9.0, 'u': 2.8, 'v': 1.0, 'w': 2.4, 'x': 0.2, 'y': 2.0, 'z': 0.1}
letter_bag = list(chain(*[[letter] * int(letter_freq[letter]*10) for letter in letter_freq]))
with ui.ImageContext(tile_size, tile_size) as ctx:
ui.set_color('silver')
ui.Path.rounded_rect(2, 2, tile_size-4, tile_size-4, 4).fill()
ui.set_color('white')
ui.Path.rounded_rect(2, 2, tile_size-4, tile_size-6, 4).fill()
tile_texture = sk.Texture(ctx.get_image())
with ui.ImageContext(100, 100) as ctx:
ui.set_color('#49b8ff')
ui.Path.oval(0, 0, 100, 100).fill()
ui.set_color('white')
point_bg_tex = sk.Texture(ctx.get_image())
class Tile (sk.SpriteNode):
def __init__(self, x, y, letter, color='white', multiplier=1):
sk.SpriteNode.__init__(self, tile_texture)
self.x = x
self.y = y
self.letter = letter
self._selected = False
pos_y = y * tile_size + (tile_size/2 if x % 2 == 0 else 0)
'''Tap anywhere on the screen to generate colorful fireworks. You can also tap with multiple fingers.'''
import sk
import sound
from ui import Path
from math import pi
from random import random, randint, choice
COLORS = ['#ffa849', '#c8ff49', '#49ffe7', '#86b0ff', '#fa86ff', '#ff3131']
TRAIL_TEXTURE = sk.Texture('shp:Spark')
STAR_TEXTURE = sk.Texture('pzl:Particle1')
EXPL_TEXTURES = [STAR_TEXTURE, TRAIL_TEXTURE]
NUM_STARS = 20
BG_COLOR = '#0c001c'
class FireworksScene(sk.Scene):
def did_start(self):
self.background_color = BG_COLOR
self.background_node = None
self.generate_star_background()
def generate_star_background(self):
if self.background_node:
self.background_node.remove_from_parent()
self.background_node = sk.Node()
w, h = self.size
for i in range(NUM_STARS):
star = sk.SpriteNode(STAR_TEXTURE)
star.position = random() * w, random() * h + 150
star.alpha = 0.5 + random() * 0.5
