def __init__(self):
super(LoadingScene, self).__init__()
# 开启事件处理层 有事件发生 就要写
cocos.layer.Layer.is_event_handler = True
d_width, d_height = cocos.director.director.get_window_size()
# 创建背景精灵
background = cocos.sprite.Sprite('Resource//loading_scene//background.png')
background.position = d_width // 2, d_height // 2
# 创建标题精灵
title = cocos.sprite.Sprite('Resource//loading_scene//title.png')
title.position = d_width // 2, d_height // 2
delay_move_to = Delay(1.0)
move_to = MoveTo((d_width // 2, d_height // 5 * 3), 2)
title.do(delay_move_to + move_to)
sub_title = cocos.sprite.Sprite('Resource//loading_scene//sub_title.png')
sub_title.position = d_width // 2, d_height // 7 * 3
sub_title.opacity = 0
fade_in = FadeIn(2.0)
delay_fade_in = Delay(2)
sub_title.do(delay_fade_in + fade_in)
self.add(background)
self.add(title)
self.add(sub_title)
def set_slide(self, slide, change='normal'):
self.get('clock').clock_shown(slide.show_clock)
out_layer=self.get('slide')
in_layer=self.__get_slide_layer(slide)
try:
self.remove('temp')
except Exception:
pass # no transition running.
try:
self.remove('temp_col')
except Exception:
pass # no transition running.
self.remove('slide')
self.add(out_layer, z=1, name='temp')
self.add(in_layer, z=0, name='slide')
transition=config.effect_mapping[change][slide.effect]
logger.debug("Changing slide with transition: %s", transition)
if transition == 'tile_swipe':
out_layer.do(FadeOutBLTiles(grid=(16, 9), duration=1) + Hide() + StopGrid())
elif transition == 'crossfade':
out_layer.do(FadeOut(duration=1))
elif transition == 'fade_red':
col_layer=ColorLayer(255, 0, 0, 0)
self.add(col_layer, z=1.1, name='temp_col')
col_layer.do(FadeIn(duration=0.3)+Delay(0.5)+FadeOut(duration=1.5))
out_layer.do(Delay(0.3) + Hide())
else:
out_layer.do(Hide())
def __init__(self):
super(Game, self).__init__(102, 102, 225, 255)
self.collision_manager = cm.CollisionManagerBruteForce()
self.player = cocos.sprite.Sprite('eleph2.png')
self.player.position = 400, 25
self.player.velocity = 0, 0
self.player.speed = 150
self.player.scale = .5
self.add(self.player, z=2)
self.player.cshape = cm.AARectShape(self.player.position,
self.player.width // 2,
self.player.height // 2)
self.collision_manager.add(self.player)
self.boss = cocos.sprite.Sprite('flaregun.png')
self.boss.position = 400, 600
self.boss.scale = 0.4
self.add(self.boss, z=1)
self.boss.cshape = cm.AARectShape(self.boss.position,
self.boss.width // 2,
self.boss.height // 2)
self.collision_manager.add(self.boss)
self.batch = cocos.batch.BatchNode()
self.enemies = [cocos.sprite.Sprite('compass.png') for i in range(6)]
positions = ((250, 125), (550, 125), (300, 325), (500, 325),
(150, 475), (650, 475))
for num, enem in enumerate(self.enemies):
enem.position = positions[num]
enem.cshape = cm.AARectShape(enem.position, enem.width // 2,
enem.height // 2)
self.collision_manager.add(enem)
self.batch.add(enem)
self.add(self.batch, z=1)
self.player.do(Move())
move_basic = MoveBy((120, 0), 1)
self.enemies[0].do(Repeat(move_basic + Reverse(move_basic)))
self.enemies[1].do(Repeat(Reverse(move_basic) + move_basic))
move_complex = (MoveBy((-75, 75), 1) + Delay(0.5) + MoveBy(
(-75, -75), 1) + Delay(0.5) + MoveBy(
(75, -75), 1) + Delay(0.5) + MoveBy((75, 75), 1) + Delay(0.5))
self.enemies[2].do(Repeat(move_complex))
self.enemies[3].do(Repeat(Reverse(move_complex)))
move_jump = AccelDeccel(JumpBy((200, 0), 75, 3, 3))
move_jump_rot = AccelDeccel(RotateBy(360, 3))
self.enemies[4].do(Repeat(move_jump + Reverse(move_jump)))
self.enemies[4].do(Repeat(move_jump_rot + Reverse(move_jump_rot)))
self.enemies[5].do(Repeat(Reverse(move_jump) + move_jump))
self.enemies[5].do(Repeat(Reverse(move_jump_rot) + move_jump_rot))
self.schedule(self.update)
def _add_animation(self, node, drink):
"""
Construct an animation path for the label.
"""
node.scale = 0.5
content_offset = (node.scale * node.label.element.content_width +
self._drink_distance) / 2
# Make sure only one item has focus
minimum_offset = (
(self._focus_length + self._focus_ramp) * self._screen_width) / 2
if content_offset < minimum_offset:
content_offset = minimum_offset
content_time = float(content_offset) / self._scroll_speed
# Set start position
node.position = (self._screen_width + content_offset, self._ticker_y)
# Construct the path
# Move to beginning of screen
(coordinates, _) = self._path[0]
move_actions = MoveTo(coordinates, content_time)
# Move to ramp up
(coordinates, time) = self._path[1]
move_actions += MoveTo(coordinates, time)
# Do the ramp
(coordinates, time) = self._path[2]
move_actions += (MoveTo(coordinates, time) |
(Delay(time / 2) + ScaleTo(1, time / 2))
| CallFunc(self._set_focused_drink, drink))
# Move in focus
(coordinates, time) = self._path[3]
move_actions += MoveTo(coordinates, time)
# Ramp down
(coordinates, time) = self._path[4]
move_actions += MoveTo(coordinates, time) | (ScaleTo(0.5, time / 2))
# Move to end of screen
(coordinates, time) = self._path[5]
move_actions += MoveTo(coordinates, time)
# Move out of sight
move_actions += MoveTo((0 - content_offset, self._ticker_y),
content_time)
# Prepare spawn point
spawn_actions = Delay(content_time * 2) + CallFunc(self._next_drink)
self.do(spawn_actions)
# Start animation
node.do(move_actions + CallFunc(self._safe_kill, node))
def __init__(self):
super(TestLayer, self).__init__()
self.add(TestFigure())
self.schedule(lambda x: 0)
if autotest:
self.do(
Delay(1.0) + CallFunc(self.upscale) + Delay(1.0) +
CallFunc(self.upscale))
def on_mouse_press(self, x, y, buttons, modifiers):
left = self.parent.get('left')
right = self.parent.get('right')
if buttons == 4:
if left.selected:
self.do(Delay(0.5) + CallFunc(left.inactivate))
elif right.selected:
self.do(Delay(0.5) + CallFunc(right.inactivate))
else:
self.cancel()
def __init__(self):
super(TestLayer, self).__init__()
x, y = director.get_window_size()
self.sprite = Sprite('grossini.png', (x // 4, y // 2))
self.add(self.sprite)
self.sprite.do(Delay(1) + ToggleVisibility())
self.sprite2 = Sprite('grossini.png', (x // 4 * 3, y // 2))
self.sprite2.visible = False
self.add(self.sprite2)
self.sprite2.do(Delay(1) + ToggleVisibility())
def __init__(self):
super(TestScene, self).__init__()
scroller = layer.ScrollingManager()
scrollable = tiles.load('road-map.xml')['map0']
scroller.add(scrollable)
self.add(scroller)
template_action = (CallFunc(scroller.set_focus, 0, 0) + Delay(1) +
CallFunc(scroller.set_focus, 768, 0) + Delay(1) +
CallFunc(scroller.set_focus, 768, 768) + Delay(1) +
CallFunc(scroller.set_focus, 1500, 768) + Delay(1) +
ScaleTo(0.75, 1) +
CallFunc(scrollable.set_debug, True) + Delay(1) +
CallFunc(director.window.set_size, 800, 600))
scroller.do(template_action)
def __init__(self):
super( HelloWorld, self ).__init__()
# a cocos.text.Label is a wrapper of pyglet.text.Label
# with the benefit of being a cocosnode
self.label = cocos.text.Label('Hi',
font_name='Times New Roman',
font_size=32,
x=320, y=240,
anchor_x='center', anchor_y='center')
self.add( self.label )
if autotest:
self.do( Delay(1) + CallFunc(self.move_label, 100, 100) +
Delay(1) + CallFunc(self.move_label, 500, 300))
def attack(self, target, gameMap):
from maps import Vertex
if type(target) == Vertex or (
(issubclass(type(target), Troop) or type(target) == Firewall)
and target.pid != self.pid):
# Clicked a vertex or an enemy troop or an enemy Firewall
if type(target) != Vertex:
target = target.curVertex
path = gameMap.get_path(self.curVertex, target, self.pid, self,
"attack")
if path and len(path) <= self.attackRange + 1:
self.attackingPath = path
self.is_attacking = True
# Move the Ping Of Death to the dest vertex
pingOfDeathAction = Delay(0)
for vertexID in path:
vertex = gameMap.vertices[vertexID]
pingOfDeathAction += MoveTo(vertex.position, self.speed)
# Execute Ping Of Death!
pingOfDeathAction += CallFunc(self.POD, target)
controller = objects.Objects.get_controller()
pingOfDeathAction += CallFunc(controller.remove_unit, self)
self.do(pingOfDeathAction)
return True
return False
def __init__(self):
super(TestLayer, self).__init__()
x, y = director.get_window_size()
self.color1 = [255, 0, 0, 255]
self.color2 = [0, 0, 255, 255]
self.label = Label('', (x // 2, y // 2))
self.label.do(Rotate(360, 10))
self.label.do(
Repeat(
Delay(1) + CallFunc(self.set_color, 0) + Delay(1) +
CallFunc(self.set_color, 1) + Delay(1) +
CallFunc(self.set_color, 2)))
self.add(self.label)
self.set_color(2)
def level_up(self):
if self.i == self.level:
if self.flag:
director.window.push_handlers(self.parent)
self.flag = False
del self
return
self.info_clear(1)
self.info_clear(2)
self.info_clear(3)
content_origin = ['Origin']
for ability in self.abilities:
content_origin.append(str(self.origin[ability]))
self.display(content_origin, font_size=20, contentid=1,
pos_range=((self.width // 3, 0), (self.width * 5 // 9, self.height)))
growth = self.growthlist[self.i]
content_grow = ['Grow']
for ability in self.abilities:
content_grow.append(str(growth[ability]))
self.display(content_grow, font_size=20, contentid=2,
pos_range=((self.width*5//9, 0), (self.width*7//9, self.height)))
content_new = ['New']
for ability in self.abilities:
self.origin[ability] = growth[ability] + self.origin[ability]
content_new.append(str(self.origin[ability]))
self.display(content_new, font_size=20, contentid=3,
pos_range=((self.width *7//9, 0), (self.width, self.height)))
self.do(Delay(0.5) + CallFunc(self.bar_raise))
self.i += 1
def __init__(self, pos):
super().__init__(Image.coin)
self.position = pos
self.scale = 0.8
self.do(MoveBy((0, 35), 0.1) + Delay(0.1) + CallFunc(self.kill))
def on_enter(self):
# handler's auto registration only happens for window's events;
# we want to listen director events, so explicitly registering
super(AutocenteredBackgroundLayer,self).on_enter()
director.push_handlers(self.on_cocos_resize)
if autotest:
self.do(Delay(2.0) + CallFunc(resize) )
def __init__(self, image, pos, maplayer):
super().__init__(image, pos, maplayer)
self.velocity = (50, 0)
self.visible = False
self.do(Delay(0.3) + Show() + ShowProp() + MoveActor())
def __init__(self):
super(TestLayer, self).__init__()
x, y = director.get_window_size()
template_action = Delay(2) + Blink(3, 3)
self.sprite = Sprite('grossini.png', (x // 2, y // 2))
self.add(self.sprite)
self.sprite.do(template_action)
self.sprite2 = Sprite('grossinis_sister1.png',
(x // 2 + 50, y // 2 + 50))
self.sprite2.scale = 0.5
self.sprite2.visible = False
self.add(self.sprite2)
self.sprite2.do(Delay(3) + template_action)
def pkmn_center_door(self, x: int, y: int) -> None:
"""Animate the pkmn center door opening or closing.
:param x: The x coordinates of the pkmn center door.
:param y: The y coordinates of the pkmn center door.
"""
reverse = True if "pkmn_center_door" in self._scroller.children_names else False
tileset = pyglet.image.load(PATH + "/assets/map/pkmn_center_door.png")
tileset_grid = pyglet.image.ImageGrid(tileset, 1, 4, MapScene.TILE_SIZE, tileset.height)
tileset_anim = pyglet.image.Animation.from_image_sequence(
reversed(tileset_grid) if reverse else tileset_grid,
0.1,
loop=False
)
animation = cocos.sprite.Sprite(tileset_anim)
animation.position = (x + MapScene.TILE_SIZE / 2, y + MapScene.TILE_SIZE + tileset.height / 2)
scrollable_layer = cocos.layer.ScrollableLayer()
scrollable_layer.add(animation)
if reverse:
self._scroller.remove("pkmn_center_door")
callback = lambda: self._scroller.remove("pkmn_center_door")
self.do(Delay(0.4) + CallFunc(callback))
self._scroller.add(scrollable_layer, z=1, name="pkmn_center_door")
def _replace_node(self, new_node):
"""
Move a new node into display, slow animation.
"""
if not self.is_running:
if debug_mode:
print("Not running")
if self._current_node:
self._current_node.kill()
self._current_node = None
return
if self._current_node:
self._current_node.do(
MoveTo(self._point_offscreen_left, 0.5 * self._move_time) +
CallFunc(self._current_node.kill))
self._current_node = UpdatableNode(new_node,
self._point_offscreen_right)
self._current_node.do(
Delay(0.5 * self._move_time) +
MoveTo(self._point_onscreen, 0.5 * self._move_time))
self.add(self._current_node)
def __init__(self):
super(TestLayer, self).__init__()
x, y = director.get_window_size()
self.sprite = Sprite('grossini.png', (x / 2, y / 2))
self.add(self.sprite)
self.sprite.do(Delay(1) + Hide())
def set_angle_action(self, proportion, max_duration=4, min_duration=2):
angle = 360 - proportion * 360
delta = abs(self.angles - angle)
if delta <= 10:
return self.right_ring, Delay(min_duration)
duration = min(1, delta / 90) * (max_duration - min_duration)
if self.angles > angle: # right rotation
if angle >= 180:
return self.right_ring, (Delay(0.5) + RotateTo(180, duration + min_duration) + CallFunc(self.change_angle, angle))
elif self.angles <= 180:
return self.right_ring, (Delay(0.5) + RotateTo(angle, duration + min_duration) + CallFunc(self.change_angle, angle))
else:
d1 = (duration + min_duration) * (self.angles - 180) / delta
d2 = duration + min_duration - d1
return self.right_ring, (Delay(0.5) + RotateTo(180, d1)
+ RotateBy(angle - 180, d2) + CallFunc(self.change_angle, angle))
else: #
if angle <= 180:
return self.right_ring, (Delay(0.5) + RotateTo(angle, duration + min_duration) + CallFunc(self.change_angle, angle))
elif self.angles >= 180:
return self.right_ring, (Delay(0.5) + RotateTo(angle, duration + min_duration) + CallFunc(self.change_angle, angle))
else:
d1 = (duration + min_duration) * (180 - self.angles) / delta
d2 = duration + min_duration - d1
return self.right_ring, (Delay(0.5) + RotateBy(180 - self.angles, d1)
+ RotateBy(angle - 180, d2) + CallFunc(self.change_angle, angle))
def getHit(self):
if self.is_dead_scene_Playing == False and self.is_shield == False:
self.total_lives -= 1
self.revive_Pattern = Place(self.startLocation) + CallFunc(
self.revive) + Blink(4, 2) + CallFunc(self.shieldoff)
self.deadtemplate = Delay(0.5) + CallFunc(self.destroy)
self.die()
if self.total_lives <= 0:
director.replace(FadeTransition(FinishScene(self.gScene)))
def __init__(self, sequence, bpm):
super().__init__()
self.left_foot = Sprite("./images/flat-black-l.png")
self.right_foot = Sprite("./images/flat-black-r.png")
self.left_foot.position = 200, 200
self.right_foot.position = 300, 200
self.add(self.left_foot)
self.add(self.right_foot)
speed = 60 / bpm
dance = [s(speed) for s in sequence]
right_leg_sequence = chain(*(step[0] for step in dance))
left_leg_sequence = chain(*(step[1] for step in dance))
self.right_foot.do(Repeat(sum(right_leg_sequence, Delay(0))))
self.left_foot.do(Repeat(sum(left_leg_sequence, Delay(0))))
def raise_flag(self, x):
ground_y = Mario.GROUND_POS_Y[self.state]
def lower_flag():
self.image = Image.mario_lower_flag[self.state]
delta_y = ground_y - self.y + 16
self.do(MoveBy((8, 0), 0.2) + MoveBy((0, delta_y), 1.8))
def turn_around_after_lower_flag():
delta_y = ground_y - self.y
self.do(MoveBy((16, 0), 0.1) + MoveBy((8, delta_y), 0.1))
self.image = Image.mario_lower_flag_turn_around[self.state]
self.do(
CallFunc(lower_flag) + Delay(2) +
CallFunc(turn_around_after_lower_flag) + Delay(0.5) +
CallFunc(Sound.play, "stage_clear") + WalkToCastle((x, ground_y)) +
CallFunc(self.kill))
def __init__(self):
super(TestLayer, self).__init__()
x, y = director.get_window_size()
self.sprite = Sprite('grossini.png')
self.add(self.sprite)
self.sprite.do(MoveTo((x, y), 10))
if autotest:
self.do(Delay(1) + CallFunc(self.resize))
def update_timer(self, dt):
stats.update_timer(dt)
if stats.time == 100:
Sound.stop("mario")
Sound.play("out_of_time")
self.do(Delay(2) + CallFunc(Sound.play, "mario"))
if stats.time <= 0:
self.game_over("timeout")
def __init__(self):
super(Game, self).__init__(102, 102, 225, 255)
self.player = cocos.sprite.Sprite(resources.player)
self.player.position = 400, 25
self.player.velocity = 0, 0
self.player.speed = 150
self.add(self.player, z=2)
self.boss = cocos.sprite.Sprite(resources.boss)
self.boss.position = 400, 600
self.boss.scale = 0.4
self.add(self.boss, z=1)
self.batch = cocos.batch.BatchNode()
self.enemies = [cocos.sprite.Sprite(resources.enemy) for i in range(6)]
positions = ((250, 125), (550, 125), (300, 325), (500, 325),
(150, 475), (650, 475))
for num, enem in enumerate(self.enemies):
enem.position = positions[num]
self.batch.add(enem)
self.add(self.batch, z=1)
self.player.do(Move())
move_basic = MoveBy((120, 0), 1)
self.enemies[0].do(Repeat(move_basic + Reverse(move_basic)))
self.enemies[1].do(Repeat(Reverse(move_basic) + move_basic))
move_complex = (MoveBy((-75, 75), 1) + Delay(0.5) + MoveBy(
(-75, -75), 1) + Delay(0.5) + MoveBy(
(75, -75), 1) + Delay(0.5) + MoveBy((75, 75), 1) + Delay(0.5))
self.enemies[2].do(Repeat(move_complex))
self.enemies[3].do(Repeat(Reverse(move_complex)))
move_jump = AccelDeccel(JumpBy((200, 0), 75, 3, 3))
move_jump_rot = AccelDeccel(RotateBy(360, 3))
self.enemies[4].do(Repeat(move_jump + Reverse(move_jump)))
self.enemies[4].do(Repeat(move_jump_rot + Reverse(move_jump_rot)))
self.enemies[5].do(Repeat(Reverse(move_jump) + move_jump))
self.enemies[5].do(Repeat(Reverse(move_jump_rot) + move_jump_rot))
def level_up(self):
print(self.i, self.level)
if self.i >= self.level:
if self.flag:
print('end')
self.flag = False
self.do(Delay(0.5) + CallFunc(self._callback))
return
self.info_clear(1)
self.info_clear(2)
self.info_clear(3)
content_origin = ['Origin']
for ability in self.abilities:
content_origin.append(str(self.origin[ability]))
self.display(content_origin,
font_size=20,
contentid=1,
pos_range=((self.width // 3, 0), (self.width * 5 // 9,
self.height)))
growth = self.growthlist[self.i]
content_grow = ['Grow']
for ability in self.abilities:
content_grow.append(str(growth[ability]))
self.display(content_grow,
font_size=20,
contentid=2,
pos_range=((self.width * 5 // 9, 0), (self.width * 7 // 9,
self.height)))
content_new = ['New']
for ability in self.abilities:
self.origin[ability] = growth[ability] + self.origin[ability]
content_new.append(str(self.origin[ability]))
self.display(content_new,
font_size=20,
contentid=3,
pos_range=((self.width * 7 // 9, 0), (self.width,
self.height)))
self.do(Delay(0.5) + CallFunc(self.bar_raise))
self.i += 1
def __init__(self):
super( TestLayer, self ).__init__()
x,y = director.get_window_size()
self.sprite = Sprite( 'grossini.png', (x//2, y//2) )
self.sprite.visible = False
self.add( self.sprite )
def make_visible( sp ):
sp.visible = True
self.sprite.do( Delay(1) + CallFunc( make_visible, self.sprite ) )
def item(self, item):
if self.selected is not None:
for name in self.parent.children_names:
if self.parent.children_names[name] == self:
self.name = name
self.parent.remove('left')
self.parent.remove('right')
self.do(
Delay(0.5) + CallFunc(
self.arena.exchange_item(self.selected, item, self.name)))
else:
self.selected = item
left = self.parent.get('left').selected
right = self.parent.get('right').selected
if left is not None and right is not None:
self.parent.remove('left')
self.parent.remove('right')
self.do(
Delay(0.5) +
CallFunc(self.arena.exchange_item(left, right)))
def __init__(self):
# call superclass with the title
super(MainMenu, self).__init__("MultiplexLayer")
l = []
l.append(MenuItem('Options', self.on_new_game))
l.append(MenuItem('Quit', self.on_quit))
self.create_menu(l)
if autotest:
self.do(Delay(1) + CallFunc(self.on_new_game))