def __init__(self, pos, travel_path, enemy):
super(Shoot, self).__init__('shoot.png', position=pos)
# move from turret's position to tank's position,
# hit the target, and self destruct
self.do(
ac.MoveBy(travel_path, 0.1) + ac.CallFunc(self.kill) +
ac.CallFunc(enemy.hit))
def showMessage(text, duration=3.5):
global currentAction
if not message in director.scene.get_children():
director.scene.add(message, z=100)
if message.active:
message.remove_action(currentAction)
message.do(message.hideAction)
message.lbl.element.text = text
currentAction = message.do(
actions.CallFunc(message.activate) + message.showAction +
actions.Delay(duration) + message.hideAction +
actions.CallFunc(message.deactivate)) # + actions.CallFunc(remove))
def push_sequence_scene():
scene_blue = Scene()
layer_blue = ColorLayer(32, 32, 255, 255)
scene_blue.add(layer_blue, z=0)
scene_blue.do(ac.Delay(2) + ac.CallFunc(pop_scene))
scene_red = Scene()
layer_red = ColorLayer(255, 32, 0, 255)
scene_red.add(layer_red, z=0)
scene_red.do(ac.Delay(2) + ac.CallFunc(pop_scene))
director.push(SequenceScene(scene_blue, scene_red))
def main():
director.init(resizable=True, fullscreen=False)
main_scene = cocos.scene.Scene()
main_scene.add(BackgroundLayer(), z=0)
action1 = ac.ShuffleTiles(grid=(16, 8), seed=2, duration=3) + ac.StopGrid()
action2 = (ac.Delay(0.5) + ac.CallFunc(toggle_fullscreen) + ac.Delay(2.0) +
ac.CallFunc(toggle_fullscreen))
combo_action = action1 | action2
# In real code after a sequence of grid actions the StopGrid() action
# should be called. Omited here to stay in the last grid action render
main_scene.do(combo_action)
director.run(main_scene)
def show_message(self, msg, callback=None):
w, h = director.get_window_size()
self.msg = cocos.text.Label(msg,
font_size=52,
font_name=consts['view']['font_name'],
anchor_y='center',
anchor_x='center',
width=w,
multiline=True,
align="center")
self.msg.position = (w / 2.0, h)
self.add(self.msg)
actions = (
ac.Show() + ac.Accelerate(ac.MoveBy((0, -h / 2.0), duration=0.1)) +
ac.Delay(1) +
ac.Accelerate(ac.MoveBy((0, -h / 2.0), duration=0.1)) +
ac.Hide()
)
if callback:
actions += ac.CallFunc(callback)
self.msg.do(actions)
def __init__(self, *args, **kwargs):
time = kwargs.pop('time', 1.5)
action_container = kwargs.pop('action_container', self)
super().__init__(*args, **kwargs)
action_container.do(actions.FadeOut(time) + actions.CallFunc(self.remove_self), target=self)
def main():
director.init(resizable=True)
director.set_depth_test()
main_scene = cocos.scene.Scene()
main_scene.add(BackgroundLayer(), z=0)
action1 = ac.WavesTiles3D(waves=2, amplitude=70, grid=(16, 16), duration=3)
action2 = (ac.Delay(0.5) + ac.CallFunc(toggle_fullscreen) + ac.Delay(2.0) +
ac.CallFunc(toggle_fullscreen))
combo_action = action1 | action2
# In real code after a sequence of grid actions the StopGrid() action
# should be called. Omited here to stay in the last grid action render
main_scene.do(combo_action)
director.run(main_scene)
def __init__(self, img, position, actions, scale=1, opacity=255):
super(SimpleActionActor, self).__init__(img,
position=position,
scale=scale,
opacity=opacity)
actions += ac.CallFunc(self.kill)
self.do(actions)
def fire(self,x,y):
tanX = abs(x - self.position[0]) / float(y)
radian = math.atan(tanX)
angle = radian * 180 / math.pi
if x < WIN_WIDTH // 2:
angle = -angle
duration = abs(angle)/200.0
self.do(actions.RotateTo(angle,duration) + actions.CallFunc(self._fire_net,x = x,y = y))
def main():
print(description)
director.init(resizable=True, width=640, height=480)
scene_green = Scene()
layer_green = ColorLayer(32, 255, 0, 255)
scene_green.add(layer_green)
scene_green.do(ac.Delay(2.0) + ac.CallFunc(push_sequence_scene))
# pyglet 1.1.4 needs this to timely pump actions
pyglet.clock.schedule(lambda dt: None)
director.run(scene_green)
def __init__(self, x, y, orientation, target, machine, delay, image):
# using universal delay calculate animation speed accordingly
self.delay = delay / 2.38
self.num_frames = 7
self.target = target
self.machine = machine
animation = self.load_animation(image, self.delay)
# depending on direction, rotate image accordingly
if orientation == 'horizontal':
animation = animation.get_transform(rotate=90)
# now create actual instance
pos = eu.Vector2(x, y)
super().__init__(animation, pos)
self.do(
ac.CallFunc(self.target.replace) +
ac.Delay(self.num_frames * self.delay) +
ac.CallFunc(self.machine.begin_reload) + ac.CallFunc(self.kill))
def __init__(self, x, y, actions, delay):
super().__init__('img/rawMaterial.png', x, y)
self.x = x
self.y = y
self.processed = False
self.cshape.r = 6
self.value = 5
self.score = 10
self.delay = delay
self.do(actions + ac.CallFunc(self.transport))
def game_over():
w, h = director.get_window_size()
layer = cocos.layer.Layer()
text = cocos.text.Label('Game Over', position=(w*0.5, h*0.5),
font_name='Oswald', font_size=72,
anchor_x='center', anchor_y='center')
layer.add(text)
scene = cocos.scene.Scene(layer)
new_scene = FadeTransition(mainmenu.new_menu()) #FadeTransition轉場景特效
func = lambda: director.replace(new_scene)
scene.do(ac.Delay(3) + ac.CallFunc(func)) #如同在main.menu.py的self.create_menu所說，場景也可以做動作，故在3秒後才切換至新場景
return scene
def on_page_changed(page, num):
# XXX record non-page-changes?
def save(num=num):
t = time.time()
filename = 'screenshot-%d.png' % num
f = open(os.path.join(options.record, 'timing.txt'), 'a')
f.write('%.1f %s\n' % (t, filename))
filename = os.path.join(options.record, filename)
buffer = pyglet.image.get_buffer_manager().get_color_buffer()
buffer.save(filename)
# delay a moment to allow rendering to complete
page.do(actions.Delay(.1) + actions.CallFunc(save))
def game_over():
w, h = director.get_window_size()
layer = cocos.layer.Layer()
text = cocos.text.Label('Game Over', position=(w/2, h/2),
font_name='Oswald', font_size=72,
anchor_x='center',
anchor_y='center')
layer.add(text)
scene = cocos.scene.Scene(layer)
new_scene = FadeTransition(mainmenu.new_menu())
func = lambda: director.replace(new_scene)
scene.do(ac.Delay(3)+ac.CallFunc(func))
return scene
def game_over():
w, h = director.get_window_size()
layer = cocos.layer.Layer()
text = cocos.text.Label('Game Over',
position=(w * 0.5, h * 0.5),
font_name=constants.OSWALD,
font_size=72,
anchor_x=constants.CENTER,
anchor_y=constants.CENTER)
layer.add(text)
scene = cocos.scene.Scene(layer)
new_scene = FadeTransition(mainmenu.new_menu())
replace_scene = lambda: director.replace(new_scene)
scene.do(ac.Delay(3) + ac.CallFunc(replace_scene))
return scene
def __onTie(self):
u"""
Execução dos efeitos quando houver empate
"""
# Para o jogo para execução dos efeitos
self.ableToPlay = False
# Definição dos efeitos
fade = actions.FadeOut(1)
for i in xrange(9):
# Faz todos sprites desaparecerem
self.sprites[i].do(fade)
# Define um atraso de 1 segundo pro jogo reiniciar
self.do(actions.Delay(1) + actions.CallFunc(self.newGame))
def game_over():
# create a text label
w, h = director.get_window_size()
layer = cocos.layer.Layer()
text = cocos.text.Label('Game Over',
position=(w * 0.5, h * 0.5),
font_name='Oswald',
font_size=72,
anchor_x='center',
anchor_y='center')
layer.add(text)
scene = cocos.scene.Scene(layer)
menu_scene = FadeTransition(mainmenu.new_menu())
show_menu = lambda: director.replace(menu_scene)
scene.do(ac.Delay(3) + ac.CallFunc(show_menu))
return scene
def game_over(over=True):
#print("game_over")
w, h = director.get_window_size()
layer = cocos.layer.Layer()
if over:
label_txt = "Game Over"
else:
label_txt = "Game Pass"
text = cocos.text.Label(label_txt,
position=(w * 0.5, h * 0.5),
font_name='Oswald',
font_size=72,
anchor_x='center',
anchor_y='center')
layer.add(text)
scene = cocos.scene.Scene(layer)
new_scene = FadeTransition(mainmenu.new_menu())
func = lambda: director.replace(new_scene)
scene.do(ac.Delay(3) + ac.CallFunc(func))
return scene
def __onWin(self):
u"""
Execução dos efeitos quando alguém ganhar
"""
# Para o jogo para execução dos efeitos
self.ableToPlay = False
# Definição dos efeitos
blink = actions.Blink(10, 1.5)
fade = actions.FadeOut(1)
for i in xrange(9):
if self.game.values[i] == self.game.lastTurn:
# Se o sprite é do jogador vencedor então fazer ele piscar
self.sprites[i].do(blink)
else:
# Se o sprite é do jogador perdedor então fazer ele desaparecer
self.sprites[i].do(fade)
# Define um atraso de 2 segundos pro jogo reiniciar
self.do(actions.Delay(1.5) + actions.CallFunc(self.newGame))
def __init__(self, pos):
super(Explosion, self).__init__(explosion_img, pos)
self.do(ac.Delay(1) + ac.CallFunc(self.kill))
def swim(self): self.do(actions.MoveTo((-100,self.position[1]),3) + actions.CallFunc(self.explode))
def fire(self,x,y): self.do(actions.MoveTo((x,y),0.5) | actions.ScaleTo(0.5,0.5) + actions.Delay(0.5) + actions.CallFunc(self.explode))
def update_contents_action(layer):
"""Return the action that update the layer content."""
def _update():
layer.update_content_after_animations(dt=1.0, scheduled=False)
return actions.CallFunc(_update)
def __init__(self, pos):
die_img = load_animation('assets/Player/pacman_die.png', 1, 11, False)
super(Die, self).__init__(die_img, pos)
self.do(ac.Delay(1) + ac.CallFunc(self.kill))
def __init__(self, pos):
super(Explosion, self).__init__(EXPLOSION_IMG, pos)
self.do(ac.Delay(1) + ac.CallFunc(self.kill))
def __init__(self, pos, offset, target):
super(Shoot, self).__init__('shoot.png', position=pos)
self.do(
ac.MoveBy(offset, 0.1) + ac.CallFunc(self.kill) +
ac.CallFunc(target.hit))
def replace(self):
self.do(ac.Delay(0.15) + ac.CallFunc(self.load_product))
self.processed = True
def e_burn(self):
self.state = 'burning'
self.color = (180, 0, 0)
template_action = ac.Delay(2.0) + ac.CallFunc(self.e_free)
self.do(template_action)
def __init__(self, note: BaseNote):
def p(state: BaseNote.NoteState):
res = copy.copy(state)
res.pos *= settings.size
res.speed *= settings.size
return res
states = list(map(p, sorted(note.states, key=lambda e: e.sec)))
dis = 0
img = 'click.png'
if isinstance(note, Drag):
img = 'drag.png'
elif isinstance(note, Flick):
img = 'flick.png'
elif isinstance(note, Hold):
img = 'hold.png'
sec = note.tap_sec
length = 0
for i in states:
if i.sec <= note.tap_sec:
continue
length += i.speed * (i.sec - sec)
sec = i.sec
length += states[-1].speed * (note.end_sec - sec)
dis += length // 2
sec = note.tap_sec
for i in states[::-1]:
if i.sec > note.tap_sec:
break
note.show_sec = min(
note.show_sec,
sec - (settings.size * 2 - abs(dis) + (length if isinstance(note, Hold) else 0)) / abs(i.speed)
)
dis += (sec - i.sec) * i.speed
sec = i.sec
note.show_sec = min(
note.show_sec,
sec - (settings.size * 2 - abs(dis) + (length if isinstance(note, Hold) else 0)) / abs(states[0].speed)
)
dis += sec * states[0].speed
super().__init__(img, (states[0].pos, dis))
if isinstance(note, Hold):
self.scale_y = length / self.image.height
action = cac.Hide()
sec = 0
speed = states[0].speed
for i in states:
if i.sec > note.tap_sec:
break
dis -= (i.sec - sec) * speed
act = cac.MoveTo((i.pos, dis), i.sec - sec)
if sec <= note.show_sec < i.sec:
act |= cac.Delay(note.show_sec - sec) + cac.Show()
action += act
sec = i.sec
speed = i.speed
act = cac.MoveTo((states[-1].pos, length // 2 if isinstance(note, Hold) else 0), note.tap_sec - sec)
if sec <= note.show_sec < note.tap_sec:
act |= cac.Delay(note.show_sec - sec) + cac.Show()
action += act
action += cac.CallFunc(play_sound)
if isinstance(note, Hold):
class Qwq(cac.IntervalAction):
def init(self, length, duration):
self._length = length
self.duration = duration
def start(self):
self._cur = self.target.scale_y
def update(self, t):
from random import randint
if randint(0, 6) < 3:
self.target.parent.add(NoteExplode((self.target.x, 0)))
self.target.scale_y = (self._cur - self._length) * (1 - t) + self._length
nowlen = length // 2
sec = note.tap_sec
for i in states:
if i.sec <= note.tap_sec:
continue
nowlen -= (i.sec - sec) * i.speed
action += cac.MoveTo((states[-1].pos, nowlen // 2), i.sec - sec) | \
Qwq(nowlen / self.image.height, i.sec - sec)
sec = i.sec
action += cac.MoveTo((states[-1].pos, 0), note.end_sec - sec) | \
Qwq(0, note.end_sec - sec)
def explode(e: NoteSprite):
e.kill()
e.parent.add(NoteExplode((e.x, e.y)))
score()
action += cac.CallFuncS(explode)
self.do(action)
