def transport(self):
if self.receive_structure is None or self.send_structure is None or self.transporting_resource is None:
return
if self.receive_structure.isDead or self.send_structure.isDead:
return
if self.transporting_resource not in self.send_structure.storage.keys(
):
return
if self.transporting_resource not in self.receive_structure.storage.keys(
):
return
if self.tempStorage == 0:
if self.send_structure.send(self.transporting_resource):
self.tempStorage = 1
self.parent.add(
SimpleActionActor(
'assets/%s.png' % self.transporting_resource,
self.send_structure.position,
ac.FadeIn(0.5) | ac.MoveTo(self.position, 1),
opacity=0))
if self.tempStorage == 1:
if self.receive_structure.receive(self.transporting_resource):
self.tempStorage = 0
self.parent.add(
SimpleActionActor(
'assets/%s.png' % self.transporting_resource,
self.position,
ac.FadeIn(0.5)
| ac.MoveTo(self.receive_structure.position, 1),
opacity=0))
def distribute(self):
for obj in self.parent.get_children():
if hasattr(obj, 'receive'):
if isinstance(obj, Warehouse):
continue
if mt.distance(self.position, obj.position) > self.range:
continue
if self.storage['copper'] >= 1:
if obj.receive('copper'):
self.storage['copper'] -= 1
self.parent.add(
SimpleActionActor('assets/copper.png',
self.position,
ac.FadeIn(0.5)
| ac.MoveTo(obj.position, 1),
opacity=0))
if self.storage['iron'] >= 1:
if obj.receive('iron'):
self.storage['iron'] -= 1
self.parent.add(
SimpleActionActor('assets/iron.png',
self.position,
ac.FadeIn(0.5)
| ac.MoveTo(obj.position, 1),
opacity=0))
if self.storage['titanium'] >= 1:
if obj.receive('titanium'):
self.storage['titanium'] -= 1
self.parent.add(
SimpleActionActor('assets/titanium.png',
self.position,
ac.FadeIn(0.5)
| ac.MoveTo(obj.position, 1),
opacity=0))
if self.storage['BasicBullet'] >= 1:
if obj.receive('BasicBullet'):
self.storage['BasicBullet'] -= 1
self.parent.add(
SimpleActionActor('assets/BasicBullet.png',
self.position,
ac.FadeIn(0.5)
| ac.MoveTo(obj.position, 1),
opacity=0))
if self.storage['CannonBullet'] >= 1:
if obj.receive('CannonBullet'):
self.storage['CannonBullet'] -= 1
self.parent.add(
SimpleActionActor('assets/CannonBullet.png',
self.position,
ac.FadeIn(0.5)
| ac.MoveTo(obj.position, 1),
opacity=0))
def updateSpeed(self, dt):
if (self.s.currentLevel > g.script_startflying):
self.currentSprite.do(
ac.MoveTo((g.screenWidth / 2,
self.currentSprite.y - self.s.currentSpeed),
duration=updateInterval))
self.prevSpr.do(
ac.MoveTo(
(g.screenWidth / 2, self.prevSpr.y - self.s.currentSpeed),
duration=updateInterval))
self.nextSpr.do(
ac.MoveTo(
(g.screenWidth / 2, self.nextSpr.y - self.s.currentSpeed),
duration=updateInterval))
def __set_bullet_time(self):
bullet_time = self.target.bullets.next()
bullet_time.stop()
try:
if bullet_time.sprite_move_action.done():
bullet_time.sprite_move_action = actions.MoveTo(
(self.target.position[0], HEIGHT * 1.1), 5)
except Exception:
bullet_time.sprite_move_action = actions.MoveTo(
(self.target.position[0], HEIGHT * 1.1), 5)
bullet_time.position = self.target.position
try:
self.target.parent.remove(bullet_time)
except Exception:
pass
self.target.parent.add(bullet_time)
bullet_time.do(bullet_time.sprite_move_action)
def __init__(self, x, y, state):
super(FallingBoxSprite, self).__init__('assets/circle.png', scale = spriteScale)
self.position = x,y
action = ac.MoveTo((self.position[0], -g.consts["window"]["height"]*1.25), 8)
self.do(action)
self.schedule_interval(self.checkForDeath, 0.25)
self.haveAppliedPenalty = False
self.s = state
def showMessage(
self,
message="Your game must be restarted in order to apply these settings."
):
if not self.active:
self.lbl.element.text = message
self.do(
actions.AccelDeccel(
actions.MoveTo((int(self.x), 0), duration=0.5)))
self.active = True
def __init__(self, width=None, height=None):
super().__init__(100, 100, 100, 100, width=width, height=height)
self.width = reswidth
self.height = int(resheight * 0.07)
self.x = 0
self.y = resheight
self.showAction = actions.AccelDeccel(
actions.MoveTo((self.x, resheight - self.height), 0.5))
self.hideAction = actions.AccelDeccel(
actions.MoveTo((self.x, resheight), 0.5))
self.lbl = text.Label("",
anchor_x="center",
anchor_y="center",
font_size=18)
self.lbl.x = self.width / 2
self.lbl.y = self.height / 2
self.active = False
self.add(self.lbl)
def __init__(self, line: Line):
class Qwq(cac.IntervalAction):
def init(self, width, duration):
self._width = width
self.duration = duration
def start(self):
self._cur = self.target.scale_y
def update(self, t):
self.target.scale_y = (self._cur - self._width) * (1 - t) + self._width
def p(state: Line.LineState):
res = copy.copy(state)
res.x *= settings.size
res.x += (settings.width - settings.size) / 2
res.y *= settings.size
res.y += (settings.height - settings.size) / 2
return res
states = list(map(p, sorted(line.states, key=lambda e: e.sec)))
super().__init__('line_empty.png', (states[0].x, states[0].y), states[0].angle)
for note in line.notes:
self.add(NoteSprite(note))
line_sprite = cocos.sprite.Sprite('line.png')
self.add(line_sprite)
action = None
pre = states[0]
for i in states[1:]:
act = cac.MoveTo((i.x, i.y), i.sec - pre.sec) | cac.RotateBy(i.angle - pre.angle, i.sec - pre.sec)
if i.rev != pre.rev:
act |= cac.Delay(i.sec - pre.sec) + cac.FlipY(duration=0.01)
if not action:
action = act
else:
action += act
pre = i
if action:
self.do(action)
action = None
sec = 0
for i in states:
act = Qwq(i.width, i.sec - sec)
if not action:
action = act
else:
action += act
sec = i.sec
if action:
line_sprite.do(action)
def move(self, check=True):
cell = self.owner.map.get_at_pixel(self.x, self.y)
self.checkOrientation()
x, y = self.orientation
cell = self.owner.map.get_neighbor(cell, self.orientation)
try:
if not "wall" in cell.tile.id or not check:
self.walkAnim.start()
newX = self.x + self.movAmount*x
newY = self.y + self.movAmount*y
self.do(actions.MoveTo((newX, newY), self.animTime))
except AttributeError:
print "You are trying to exceed map limits"
def distribute(self):
if self.storage[self.miningResource] <= 0:
return False
for obj in self.parent.get_children():
if hasattr(obj, 'receive'):
if mt.distance(self.position, obj.position) > self.range:
continue
if obj.receive(self.miningResource):
self.storage[self.miningResource] -= 1
self.parent.add(
SimpleActionActor(
'assets/%s.png' % self.miningResource,
self.position,
ac.FadeIn(0.5) | ac.MoveTo(obj.position, 1),
opacity=0))
def run_draw_card_animations(layer, event):
card, player_id = event.card, event.player_id
i = layer.player_id_to_i(player_id)
hand_sprites = layer.hand_sprites[i]
spr_kw = {
'position': pos(layer.RightCX, layer.DeckY[i]),
'is_front': (i == 0), 'scale': 0.35,
'sel_mgr_kwargs': {'set_default': i == 0}, 'selected_effect': None, 'unselected_effect': None}
new_sprite = HandSprite(card, **spr_kw)
assert new_sprite not in hand_sprites
hand_sprites.append(new_sprite)
new_sprite.add_to_layer(layer)
layer.do_animation(
actions.MoveTo(pos(layer.HeroL, layer.HandY[i]), duration=C.UI.Cocos.Animation.DrawCardTime),
target=new_sprite)
def __init__(self, towerParent, target, image, towerNumber, rotation,
speed, damage, effect, effectDuration, effectFactor):
"""
Create a projectile.
:Parameters:
`towerParent`: tower object
Tower that launched the projectile.
`target` : enemy object
Enemy that is targeted.
`image` : image
Image of the projectile.
`towerNumber` : int
Number of the parent tower.
`rotation` : int
Rotation of the parent tower.
`speed` : int
Speed of the projectile.
`damage` : int
Damage the projectile causes.
`effect` : string
Effect that is caused by projectile (like poison or normal)
`effectDuration` : int
Duration that the effect is active.
`effectFactor` : int
How strong the effect is.
"""
super().__init__(image, position=towerParent.position, scale=1)
self.rotation = rotation
self.damage = damage
self.speed = speed
self.distance = self._distance(target.position, self.position)
self.duration = self._duration()
self.do(actions.MoveTo(target.position, self.duration))
self.schedule_interval(self._dispatch_hit_event, self.duration, target,
towerNumber, effect, effectDuration,
effectFactor)
def on_key_press (self, k, modifiers):
if (k in g.keyBindings):
self.s.timeLastKeyPress = time.time()
children = self.boxes[g.keyBindings.index(k)]
if(children):
bestOne = min([abs(child.y - g.hitBoxHeight) for child in children])
bestChild = [child for child in children if abs(child.y - g.hitBoxHeight) == bestOne][0] #yuck
if(bestChild):
if(bestOne < 8.5):
children.remove(bestChild)
action = (ac.MoveTo((bestChild.x, g.hitBoxHeight)) | ac.FadeOut(0.25) | ac.ScaleBy(1.75, 0.25) ) + ac.CallFuncS(self.remove_child)
bestChild.do(action)
self.s.currentSpeed += 2.5
self.sounds[g.keyBindings.index(k)].play() # Play right now
elif (bestOne < 20):
children.remove(bestChild)
action = (ac.FadeOut(0.25)) + ac.CallFuncS(self.remove_child)
bestChild.do(action)
self.s.currentSpeed += 1
self.missSounds[g.keyBindings.index(k)].play() # Play right now
else:
#apply penalty! (to stop spamming)
self.s.currentSpeed -= 5
def run_play_minion_animations(layer, event):
minion, player_id, loc = event.minion, event.player_id, event.summon_event.loc
i = layer.player_id_to_i(player_id)
play_sprites = layer.play_sprites[i]
sprite_in_hand = _find_sprite(minion, where=layer.hand_sprites[i])
if sprite_in_hand is None:
# If not found original hand, do not run animations.
return
spr_kw = {
'position': sprite_in_hand.position,
'scale': 1.0}
new_sprite = MinionSprite(minion, **spr_kw)
assert new_sprite not in play_sprites
play_sprites.insert(loc, new_sprite)
new_sprite.add_to_layer(layer)
layer.do_animation(
actions.MoveTo(pos(
layer.BoardL + (2 * loc + 1) / (2 * len(play_sprites)) * (layer.HeroL - layer.BoardL),
layer.PlayY[i]), duration=C.UI.Cocos.Animation.PlayMinionTime),
target=new_sprite)
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)
import cocos
import cocos.actions as ac
if __name__ == '__main__':
cocos.director.director.init(caption='Actions')
layer = cocos.layer.Layer()
sprite = cocos.sprite.Sprite('tank.png', position=(200, 200))
sprite.do(ac.MoveTo((250, 300), 3))
layer.add(sprite)
scene = cocos.scene.Scene(layer)
cocos.director.director.run(scene)
def move_to(self, x, y):
self.do(ac.MoveTo((x, y), duration=self._movement_speed))
print("Moving from: {0}".format(self.position))
return self._movement_speed
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 paint(self, dt):
act = actions.MoveTo((self.cord.real + left_offset, self.cord.imag + down_offset), dt)
self.sprite.do(act)