class WixaPortal(Scene):
def __init__(self):
super(WixaPortal, self).__init__()
w, h = director.get_window_size()
self.xds = Layer()
for i in range(0, 180, 10):
xd = Line("xD " * 20, 50, (255, 255, 0, 255), w // 2, h // 2,
"November", pyglet.font.Text.CENTER,
pyglet.font.Text.CENTER)
xd.rotation = i
xd.do(Repeat(CallFunc(xd.update_line) + Delay(0.05)))
self.xds.add(xd)
self.add(self.xds)
x, y = w // 2, h // 2
s = get_sprite('krawczyk.png', x, y)
s.do(Repeat(RotateTo(20, 0.2) + RotateTo(-10, 0.2)))
self.add(s)
self.wixa1 = get_sprite('wixapol-full.png', x, y)
# self.wixa1.do(R_ScaleFromTo(1.5, 0.3, 0.3))
self.wixa1.do(R_Blink(15, 3))
self.add(self.wixa1)
class Podium(Scene):
def __init__(self):
super(Podium, self).__init__()
self.podium = Layer()
self.podium.is_event_handler = True
self.podium.on_key_press = self.on_key_press
center = director.window.width / 2
podium_sprite = Sprite('podium.png')
podium_sprite.image_anchor_y = 0
podium_sprite.x = center
self.podium.add(podium_sprite)
top_3 = state.cup.total_ranking[:3]
for index, car in enumerate(top_3):
label = util.Label(text=car.name,
font_size=25,
anchor_y='bottom',
anchor_x='center')
label.x = center + (X_DIR[index] * BLOCK_WIDTH)
label.y = HEIGHTS[index] + 20
self.podium.add(label, z=3)
self.add(self.podium, z=2)
fireworks = Fireworks()
fireworks.x = center
fireworks.y = director.window.height / 2 + 100
self.add(fireworks, z=1)
if state.profile.car in top_3:
position = top_3.index(state.profile.car)
earned = MONEY[position]
head_text = 'You earned $%d!' % (earned, )
state.profile.money += earned
state.profile.save()
if position == 0:
head_text = 'Congratulations! ' + head_text
else:
head_text = 'Better luck next time!'
head_label = util.Label(text=head_text,
font_size=30,
anchor_x='center',
anchor_y='bottom')
head_label.x = center
head_label.y = director.window.height - 75
self.add(head_label, z=3)
def on_key_press(self, symbol, modifier):
if symbol in [key.ESCAPE, key.RETURN, key.SPACE]:
director.pop()
return True
def add(self, child, z=0, name=None):
"""own add function, so background color and ordering is covered"""
Layer.add(self, child, z, name)
if name != "background":
self._update_dimensions()
self._update_background_size()
if self.side != "manual":
self._update_children_position()
class Start_Screen(Scene):
def __init__(self):
Scene.__init__(self)
self.add(
Sprite(image=pyglet.resource.image('background.png'),
position=(self.anchor_x,
self.anchor_y))) # Background Image
black_fade = ColorLayer(0, 0, 0, 0)
black_fade.opacity = 120
self.add(black_fade)
menu = Menu("TETRIS")
menu.position = (0, -60)
menu.font_title["font_name"] = "Tetrominoes"
menu.font_title["color"] = (214, 178, 152, 255)
menu.font_item["font_name"] = "Ravie"
menu.font_item_selected["font_name"] = "Ravie"
menu_items = [
MenuItem('Start Game',
game_controller.game_controller.init_new_game),
MenuItem('Ranking', self.show_ranking),
MenuItem('Quit', game_controller.game_controller.close_scene)
]
menu.menu_hmargin = 10
menu.create_menu(menu_items)
menu.on_quit = self.on_quit
self.menu_lyr = Layer()
self.menu_lyr.add(menu)
self.rank = Ranking()
self.multi_layer = MultiplexLayer(self.menu_lyr, self.rank)
self.add(self.multi_layer)
def show_ranking(self):
self.multi_layer.switch_to(1)
self.rank.show_rank()
def on_rank_exit(self):
self.multi_layer.switch_to(0)
def on_quit(self): # ao pressionar ESC executa este metodo
game_controller.game_controller.close_scene()
def test_add(self):
positions = {
"left": (320, 249.0),
"right": (101, 249.0),
"top": (254.0, 204),
"bottom": (254.0, 240)
}
for side in positions:
frame = Frame(background_color=(0, 0, 98, 255), side=side)
frame.position = 320, 240
layer = Layer()
scene = Scene()
layer.add(frame)
scene.add(layer)
label = Label("Hello World")
label_new = Label("Hello World again")
frame.add(label)
frame.add(label_new)
class Battlefiled(Scene):
is_event_handler = True
def __init__(self):
super(Battlefiled, self).__init__()
self.background = Layer()
self.player = PlayerLayer()
self.map = cocos.tiles.load('sources/map.tmx')['map']
self.map.set_view(0, 0, 16 * 32, 16 * 32)
self.add(self.map)
self.add(self.background)
self.add(self.player)
label = Label('Battlefiled',
font_name='Times New Roman',
font_size=32,
anchor_x='center',
anchor_y='center')
label.position = 512, 20
self.background.add(label)
self.posion = Poisoner(self.map)
self.posion.setPoisonRegion((64, 64), 128)
self.schedule_interval(self.schedWork, 1)
def schedWork(self, i):
players = self.player.getAll()
for p in self.posion.filterPoisoned(players):
p.human.hurt(10)
def newPlayer(self, name):
p = Player(self.map, name)
width = len(self.map.cells) - 1
height = len(self.map.cells[0]) - 1
x, y = randint(0, width), randint(0, height)
p.position = tuple(self.map.cells[x][y].center)
self.player.add(p)
class LoadTrack(Scene):
def __init__(self, track):
Scene.__init__(self)
self.text = 'Loading...'
self.track = track
self.layer = Layer()
self.label = Label(self.text + '0%', position=(100, 100))
self.layer.add(self.label)
self.add(self.layer)
self.schedule(self.load_track)
self.images_loaded = False
self.overlay_loaded = False
def load_track(self, dt, *args, **kwargs):
if not self.images_loaded:
self.track.load_images()
self.label.text = self.text + '5%'
self.total = len(self.track.partition_list)
self.images_loaded = True
elif not self.overlay_loaded:
self.track.load_overlay()
self.label.text = self.text + '25%'
self.overlay_loaded = True
else:
partitions_left = self.track.load_partitions()
percent = 25 + int(
((self.total - partitions_left) * 1.0 / self.total) * 75)
self.label.text = self.text + str(percent) + '%'
if partitions_left == 0:
# load the music last
self.track.load_music()
# hack to prevent circular imports
from race import Race
race = Race(self.track, [
state.profile.car,
ComputerCar.get_default(),
ComputerCar.get_default()
])
director.replace(race)
def __init__(self):
super(SportySpice2, self).__init__()
w, h = director.get_window_size()
l = Layer()
demon = get_sprite('mememe_evil.jpg', w // 2, h // 2 - 270)
demon.scale = 0.7
demon.do(R_Blink(10, 3))
demon.transform_anchor = 0, h // 2
l.add(demon)
# demon.do(R_ScaleFromTo(3, 1, 0.2))
# self.add(demon)
sporty = cocos.text.RichLabel("S\nP\nO\nR\nT\nY",
x=w // 2,
y=h // 2,
font_name="November",
multiline=True,
width=50,
color=(255, 255, 0, 255),
font_size=60)
sporty.transform_anchor = w // 2, h // 2
sporty.rotation = -25
sporty.position = -300, 300
# sporty.do(R_ScaleFromTo(1, 1.3, 0.1))
# sporty.do(Shaky3D())
# self.add(sporty)
l.add(sporty)
spice = cocos.text.RichLabel("S\nP\nI\nC\nE",
x=w // 2,
y=h // 2,
font_name="November",
multiline=True,
width=50,
color=(255, 255, 0, 255),
font_size=60)
spice.transform_anchor = w // 2, h // 2
spice.rotation = 30
spice.position = 300, 300
l.add(spice)
# self.add(spice)
l.transform_anchor = w // 2, h // 2 + 200
l.do(R_ScaleFromTo(3, 1, 0.2))
self.add(l)
class Sylwester(Scene):
def __init__(self):
super(Sylwester, self).__init__()
anim = Picolo('assets/picolos.png')
self.callbacks1 = Callbacks1(self)
self.layer1_init()
self.layer2_init()
self.do(
Repeat(
CallFunc(self.layer1_reset) + CallFunc(self.layer1_start) +
Delay(20) + CallFunc(self.layer2_reset) +
CallFunc(self.layer2_start) + Delay(20)))
def layer1_init(self):
w, h = director.get_window_size()
self.group1 = []
self.l1 = Layer()
self.l1.visible = False
self.xds = Layer()
for i in range(0, 18):
xd = Line("xD " * 20, 50, (255, 255, 0, 255), w // 2, h // 2,
"November", pyglet.font.Text.CENTER,
pyglet.font.Text.CENTER)
xd.do(Repeat(CallFunc(xd.update_line) + Delay(0.05)))
self.xds.add(xd)
# self.xds.do(R_Blink(10, 2))
self.xds.do(Repeat(RotateBy(-20, 0.4)))
self.xds.do(R_ScaleFromTo(1.2, 0.9, 0.3))
self.l1.add(self.xds)
self.picolos = Layer()
for i in range(0, 370, 10):
s = cocos.sprite.Sprite(Picolo.animation,
position=(w // 2, h // 2),
scale=0.8)
s.rotation = i
s.position = (w // 2, h // 2)
if i == 0:
s.scale = 0.1
s.visible = i == 0
self.group1.append(s)
self.picolos.add(s)
self.l1.add(self.picolos)
x, y = 0 - 300, h // 2
self.wixa1 = get_sprite('wixapol-full.png', x, y)
self.wixa1.scale = 0.3
self.wixa1.do(R_Blink(20, 3))
self.l1.add(self.wixa1)
x, y = w + 300, h // 2
self.wixa2 = get_sprite('wixapol-full.png', x, y)
self.wixa2.scale = 0.3
self.wixa2.do(R_Blink(20, 3))
self.l1.add(self.wixa2)
self.l1.visible = False
self.add(self.l1)
def layer1_start(self):
self.l1.visible = True
self.l2.visible = False
self.l1.resume()
self.l2.pause()
self.do(
CallFunc(self.callbacks1.scale_picolo) + Delay(1) +
CallFunc(self.callbacks1.duplicate_picolo) +
CallFunc(self.callbacks1.center_logos))
def layer1_reset(self):
w, h = director.get_window_size()
for picolo in self.group1:
picolo.visible = False
for k, xd in enumerate(self.xds.get_children()):
xd.rotation = k * 10
self.picolos.stop()
self.picolos.rotation = 0
self.group1[0].visible = True
self.group1[0].scale = 0.1
self.wixa1.position = -300, h // 2
self.wixa2.position = w + 300, h // 2
self.wixa1.opacity = self.wixa2.opacity = 255
self.wixa1.scale = self.wixa2.scale = 0.3
def layer2_init(self):
w, h = director.get_window_size()
self.l2 = Layer()
self.l2.visible = False
self.stallone = Layer()
bg = get_sprite('jungle.jpg', w // 2, h // 2)
bg.scale = 1.3
bg.do(R_ScaleFromTo(2, 1.3, 0.1))
self.stallone.add(bg)
s = get_sprite('stallone.png', w // 2, h // 2 + 100)
s.scale = 1.35
s.do(Repeat(Shaky3D(randrange=2, grid=(32, 24), duration=5)))
s.do(R_ScaleFromTo(2, 1.3, 0.2))
self.stallone.add(s)
self.l2.add(self.stallone)
txt = Line("TOTALNE ",
100, (255, 255, 0, 255),
w // 2,
h // 2,
"November",
anchor_x=pyglet.font.Text.CENTER,
anchor_y=pyglet.font.Text.CENTER)
txt.do(Repeat(CallFunc(txt.update_line) + Delay(0.1)))
txt.transform_anchor = w // 2, h // 2
txt.position = -600, 0
txt.rotation = 60
self.l2.add(txt)
txt = Line("ZNISZCZENIE ",
100, (255, 255, 0, 255),
w // 2,
h // 2,
"November",
anchor_x=pyglet.font.Text.CENTER,
anchor_y=pyglet.font.Text.CENTER)
txt.do(Repeat(CallFunc(txt.update_line) + Delay(0.1)))
txt.transform_anchor = w // 2, h // 2
txt.position = 600, 0
txt.rotation = -60
self.l2.add(txt)
wixa = get_sprite('wixapol-full.png', 200, 250)
wixa.scale = 0.3
wixa.do(R_Blink(20, 3))
self.l2.add(wixa)
wixa = get_sprite('wixapol-full.png', w - 200, 250)
wixa.scale = 0.3
wixa.do(R_Blink(20, 3))
self.l2.add(wixa)
self.add(self.l2)
def layer2_reset(self):
pass
def layer2_start(self):
self.l2.visible = True
self.l1.visible = False
self.l1.pause()
self.l2.resume()
def add(self, player):
self.players[player.name] = player
Layer.add(self, player)
class Personinfo(Info):
# 显示个人的信息
def __init__(self, person, callback=None, **kwargs):
super(Personinfo, self).__init__()
self.add(Back(position=(self.width // 72, self.height // 20),
size=(self.width // 24, int(self.height * 0.9)),callback=self._callback, switch=self.switch))
self.add(Back(position=(self.width * 17 // 18, self.height // 20),
size=(self.width // 24, int(self.height * 0.9)),callback=self._callback, switch=self.switch))
self.callback = callback
self.kwargs = kwargs
self.layer1 = Layer()
self.layer2 = Layer()
self.add(self.layer1)
self.add(self.layer2)
self.person = person
self.info_display(person)
self.layer2.visible = False
def switch(self):
if self.layer1.visible:
self.layer2.visible = True
self.layer1.visible = False
else:
self.layer1.visible = True
self.layer2.visible = False
def _callback(self):
self.parent.remove(self)
self.callback.__call__(**self.kwargs)
del self
def info_display(self, person):
p = person #type: Person
self.icon = Sprite(image=p.icon)
h, w = self.icon.height, self.icon.width
self.icon.scale_x, self.icon.scale_y = 240 / w, 240/ h
self.icon.position = self.width * 1 // 4, self.height * 3 // 4
self.add(self.icon)
content = []
content.append(p.name)
content.append(str(p.cls) + ' Lv.' + str(p.ability['LV']))
content.append('HP ' + str(p.ability['HP']) + '/' + str(p.ability['MHP']))
self.display(content, ((self.width // 18, self.height // 4),
(self.width // 2, self.height * 5 // 8)))
abilities_1 = ["MHP","STR","MGC","SPD","SKL"]
abilities_2 = ["DEF","RES","LUK","BLD","CRY"]
content = abilities_1.copy()
for ability in abilities_1:
content.append(str(p.ability[ability]))
content.extend(abilities_2)
for ability in abilities_2:
content.append(str(p.ability[ability]))
content_map = layout_multiply(content, row=5, column=4, pos_range=(
(self.width // 2, self.height * 2 // 3), (self.width * 17 // 18, self.height)))
for column in content_map:
for item in column:
self.layer1.add(item)
wp_types_1 = ["Sword","Lance","Axe","Bow","Fire"]
wp_types_2 = ["Thunder","Wind","Light","Dark","Wand"]
content = wp_types_1.copy()
for wp_type in wp_types_1:
content.append(str(get_weapon_rank(p.weapon_rank[wp_type])))
content.extend(wp_types_2)
for wp_type in wp_types_2:
content.append(str(get_weapon_rank(p.weapon_rank[wp_type])))
content_map = layout_multiply(content, row=5, column=4, pos_range=(
(self.width // 2, self.height // 3), (self.width * 17 // 18, self.height * 2 // 3)))
for column in content_map:
for item in column:
self.layer1.add(item)
content = []
for item in p.item:
content.append(item.itemtype.name + ' ' + str(item.use) + '/' + str(item.itemtype.max_use))
lay_out = layout(content, pos_range=((self.width // 2, self.height // 2),
(self.width * 17 // 18, self.height)))
for item in lay_out:
self.layer2.add(item)
content = p.skills.copy()
content.extend(self.kwargs['map'].global_vars.clsBank[p.cls].cls_skills)
content_map = layout_multiply(content, row=4, column=2, pos_range=(
(self.width // 2, self.height // 6), (self.width * 17 // 18, self.height // 3)))
for column in content_map:
for item in column:
self.layer1.add(item)
content = []
for state in p.status:
content.append(state)
content.append(str(p.status[state]))
content_map = layout_multiply(content, row=4, column=2, pos_range=(
(self.width // 2, 0), (self.width * 17 // 18, self.height // 6)))
for column in content_map:
for item in column:
self.layer1.add(item)
class CrystalSkulls(Scene):
def __init__(self):
super(CrystalSkulls, self).__init__()
w, h = director.get_window_size()
s = get_sprite('bones.png', w // 2, h // 2)
s.do(R_ScaleFromTo(2, 1, 0.3))
self.add(s)
self.l1 = Layer()
self.l1.add(Skulls())
s = get_sprite('wixapol.png', w // 2 - 80, h // 2 + 50)
s.do(R_ScaleFromTo(1.2, 0.2, 0.1))
self.l1.add(s)
s = get_sprite('wixapol.png', w // 2 + 80, h // 2 + 50)
s.do(R_ScaleFromTo(1.2, 0.2, 0.1))
self.l1.add(s)
self.l1.transform_anchor = w // 2, h // 2
OFFSET_X = 400
OFFSET_Y = 200
DELAY = 0.15
self.l1.do(
Repeat((Place(
(-OFFSET_X, 0)) + Delay(DELAY) + ScaleTo(1, 0.15) + Place(
(0, 0)) + Delay(DELAY) + ScaleTo(2, 0.15) + Place(
(OFFSET_X, 0)) + Delay(DELAY) + ScaleTo(1, 0.15) +
Place((0, 0)) + Delay(DELAY) + ScaleTo(2, 0.15) + Place(
(-OFFSET_X, 0)) + Delay(DELAY) + ScaleTo(1, 0.15) +
Place((0, 0)) + Delay(DELAY) + ScaleTo(2, 0.15) + Place(
(0, OFFSET_Y)) + Delay(DELAY) + Place(
(0, 0)) + Delay(DELAY) + Place(
(0, -OFFSET_Y)) + Delay(DELAY) + Place(
(0, 0)) + Delay(DELAY) + Place(
(0, OFFSET_Y)) + Delay(DELAY) + Place(
(0, 0)) + Delay(DELAY))))
self.l2 = Layer()
s = get_sprite('skeleton.png', w // 2, h // 2)
s.scale = 0.7
s.do(
Repeat(
Twirl(center=(w // 2, 200),
grid=(16, 12),
duration=5,
twirls=6,
amplitude=0.5)))
self.l2.add(s)
for pos in ((w // 2 - 600, h // 2), (w // 2 + 600, h // 2)):
x, y = pos
s = get_sprite('wixapol-full.png', x, y)
s.scale = 0.4
s.do(
Repeat(
Place((x, y - 250)) + Delay(DELAY * 2) + Place((x, y)) +
Delay(DELAY * 2) + Place((x, y + 250)) + Delay(DELAY * 2) +
Place((x, y)) + Delay(DELAY * 2)))
s.do(R_Blink(10, 3))
self.l2.add(s)
self.add(self.l1)
self.add(self.l2)
self.is_first_layer = True
self.do(Repeat(CallFunc(self.callback) + Delay(15)))
def callback(self):
self.l1.visible = self.is_first_layer
self.l2.visible = not self.is_first_layer
self.is_first_layer = not self.is_first_layer
class Afterevent(Eventdisplay):
# here the event receives in init method is a list of events
def display(self):
self.i = 0
text_list = self.event[self.i]['Text']
text_source = self.map.global_vars.data.text
tag = self.event[self.i]['Tag']
self.event_length = len(self.event)
self.keep = Afterdialog(text_list,
text_source,
self.map,
self.w,
self.h,
tag=tag,
callback=self._callback,
info=self.dialog_info)
self.scene = Layer()
director.push(Scene(self.scene))
self.scene.add(self.keep)
self.keep.excute()
def _callback(self, **kwargs):
self.length = len(self.event[self.i]['Execute'])
self.execute()
def execute(self, i=0):
if i < self.length:
event = self.event[self.i]['Execute'][i]
_event = event.split('/')
_type = _event[0]
if _type == 'CLV':
self.map.eventlist['Villages'].pop(_event[1])
self.execute(i + 1)
elif _type == 'I':
_, _itemid, _pid = _event
if _pid == 'E':
_pid = self.dialog_info['E']
if _pid == 'V':
_pid = self.dialog_info['V'].pid
item = self.map.global_vars.itemBank[int(_itemid)]
person = self.map.global_vars.personBank[_pid]
flag = self.map.global_vars.flags['Have Transporter']
getitem = Getitem(person,
item,
flag,
self.map,
callback=self.execute,
i=i + 1)
self.scene.add(getitem)
director.window.remove_handlers(self)
elif _type == 'SF':
flag = _event[1]
self.map.global_vars.flags[flag] = True
self.execute(i + 1)
elif _type == 'R':
if 'Reinforce' not in self.kwargs:
self.kwargs['Reinforce'] = []
self.kwargs['Reinforce'].append(_event)
self.execute(i + 1)
elif _type == 'MAP':
self.kwargs['Map'] = _event[1]
self.execute(i + 1)
else:
print('Unknown event %s' % _event)
self.execute(i + 1)
pass
else:
print('next')
self.get_next_event()
def get_next_event(self):
self.i += 1
if self.i < self.event_length:
event = self.event[self.i]
text_list = event['Text']
text_source = self.map.global_vars.data.text
print(event)
if len(text_list) > 0:
if self.event[self.i - 1]['Keep'] is 1:
scene = self.keep #type: Afterdialog
scene.textlist = text_list
scene.textsource = text_source
scene.i = 0
print('Keep')
else:
scene = Afterdialog(text_list,
text_source,
self.map,
self.w,
self.h,
callback=self._callback,
info=self.dialog_info)
self.scene.add(scene)
self.keep = scene
scene.excute()
else:
self._callback()
else:
director.pop()
self.kill()
self.callback.__call__(**self.kwargs)
class Dialogscene(BaseDialog):
def __init__(self,
text_list,
text_source,
map,
w,
h,
info,
size=200,
callback=None,
**kwargs):
super().__init__(text_list, text_source)
self.map = map
self.w, self.h = w, h
self.size = size
self.callback = callback
self.kwargs = kwargs
self.info = info # dict of persons that stands for V or E
# add background
self.background = Sprite(map.scene, position=(w // 2, h // 2))
text_background = ColorLayer(0, 0, 200, 255, w, h // 3)
self.add(self.background)
self.add(text_background)
# add img
self.left = Sprite('ring.png', position=(w // 6, h // 2), opacity=0)
self.right = Sprite('ring.png',
position=(w * 5 // 6, h // 2),
opacity=0)
self.add(self.left)
self.add(self.right)
# add label
self.label = Text(text=' ', position=(w // 6, h // 3), font_size=24)
self.add(self.label)
# add text
self.text = Text(text=' ', position=(w // 2, h // 6), font_size=30)
self.add(self.text)
def excute(self):
item = self.textsource[self.textlist[self.i]]
super().excute()
if 'Branch' in item.keys():
self.add(Branch(self.map, item['Branch'], self.callback))
director.window.remove_handlers(self)
else:
if item['Type'] is 'S':
if item['Text'] is not None:
self.text.element.text = item['Text']
if item['Left'] is not None:
if item['Left'] is 'V':
item['Left'] = self.info['V'].pic
self.changeleft(item['Left'])
if item['Right'] is not None:
if item['Right'] is 'V':
item['Right'] = self.info['V'].pic
self.changeright(item['Right'])
if item['Direction'] == 0:
self.label.position = (self.w // 6, self.h // 3)
else:
self.label.position = (self.w * 5 // 6, self.h // 3)
if item['Tag'] is not None:
if item['Tag'] is 'V':
self.label.element.text = self.info['V'].name
else:
self.label.element.text = item['Tag']
else:
self.label.element.text = ''
elif item['Type'] is 'N':
if item['Text'] is not None:
self.text.element.text = item['Text']
if item['Left'] is not None:
if item['Left'] is 'V':
item['Left'] = self.info['V'].pic
self.changeleft(item['Left'])
if item['Right'] is not None:
if item['Right'] is 'V':
item['Right'] = self.info['V'].pic
self.changeright(item['Right'])
else:
self.source_error(item['Type'])
def changeleft(self, source):
self.left.kill()
if type(source) is str:
self.left = Sprite(source, position=(self.w // 6, self.h // 2))
self.left.scale_x, self.left.scale_y = \
480 / self.left.width, 640 / self.left.height
else:
self.left = Layer()
pos1, pos2 = (300, self.h // 2), (640, self.h // 2)
spr1, spr2 = Sprite(source[0],
position=pos1), Sprite(source[1],
position=pos2)
spr1.scale_x, spr1.scale_y = 480 / spr1.width, 640 / spr1.height
spr2.scale_x, spr2.scale_y = 480 / spr2.width, 640 / spr2.height
self.left.add(spr1)
self.left.add(spr2)
self.add(self.left)
def changeright(self, source):
self.right.kill()
if type(source) is str:
self.right = Sprite(source,
position=(self.w * 5 // 6, self.h // 2))
self.right.scale_x, self.right.scale_y = \
480 / self.right.width, 640 / self.right.height
else:
self.right = Layer()
pos1, pos2 = (self.w - 640, self.h // 2), (self.w - 300,
self.h // 2)
spr1, spr2 = Sprite(source[0],
position=pos1), Sprite(source[1],
position=pos2)
spr1.scale_x, spr1.scale_y = 480 / spr1.width, 640 / spr1.height
spr2.scale_x, spr2.scale_y = 480 / spr2.width, 640 / spr2.height
self.right.add(spr1)
self.right.add(spr2)
self.add(self.right)
def exit(self):
director.pop()
if self.callback:
self.callback.__call__(**self.kwargs)
class CocosScene(Layer):
def __init__(self):
super(CocosScene, self).__init__()
self._bgLayer = None
self._stageBgLayer = None
self._contentLayer = None
self._rulerLayer = None
self._borderLayer = None
self._rootNode = None
self._borderDevice = None
self._stageBorderType = 0
self.setupEditorNodes()
def setupEditorNodes(self):
# TODO:@twenty0ne
self._rulerLayer = RulersLayer()
self.add(self._rulerLayer, z=6)
# Border layer
self._borderLayer = Layer()
self.add(self._borderLayer, z=1)
self._borderDevice = cocos.sprite.Sprite("images/missing-texture.png")
self._borderLayer.add(self._borderDevice, z=1)
# Gray background
self._bgLayer = ColorLayer(128,128,128,255,width=4096,height=4096)
self._bgLayer.position = 0,0
self._bgLayer.anchor = 0,0
self.add(self._bgLayer, z=-1)
# Black content layer
self._stageBgLayer = ColorLayer(0,0,0,255,width=0,height=0)
self._stageBgLayer.anchor = 0.5,0.5
# TODO:@twenty0ne
# stageBgLayer.ignoreAnchorPointForPosition = NO
self.add(self._stageBgLayer, z=0)
self._contentLayer = Layer()
self.add(self._contentLayer)
def nextFrame(self):
# Setup border layer
bounds =
# Update rulers
self._rulerLayer.updateWithSize([700,650],[0,0],1)
def mouseEntered(self):
# print "mouseEntered"
self._rulerLayer.mouseEntered()
def mouseExited(self):
# print "mouseExited"
self._rulerLayer.mouseExited()
def mouseMoved(self, pos):
# print "mouseMoved"
self._rulerLayer.updateMousePos(pos)
def replaceRootNodeWith(self, node):
if self._rootNode:
self._contentLayer.remove(self._rootNode)
self._rootNode = node
if not node:
return
self._contentLayer.add(node)
def setStageBorder(self, ntype):
self._borderDevice.visible = False
if self._stageBgLayer.width == 0 or self._stageBgLayer.height == 0:
ntype = kCCBBorderNone
self._stageBgLayer.visible = False
else:
self._stageBgLayer.visible = True
if ntype == kCCBBorderDevice:
deviceTexture = None
rotateDevice = True
if rotateDevice:
self._borderDevice.rotation = 90
else:
self._borderDevice.rotation = 0
deviceTexture = pyglet.resource.image("images/frame-iphone.png")
self._borderDevice.image = deviceTexture
self._borderDevice.visible = True
self._stageBorderType = ntype
