def get_next_action(self):
if self.obj1.busy or self.obj2.busy:
return
self.i += 1
if self.i >= len(self.events):
print(self.i)
self.exit()
return
event = self.events[self.i]
print(event)
color = (0, 255, 0, 255)
if event[0] < 0: # show info on screen
content = event[1]
if content is 'Defeatenemy':
if event[0] is -1:
self.map.defeated_character(self.df.pid)
self.defeat = self.at.pid
elif event[0] is -2:
self.map.defeated_character(self.at.pid)
self.defeat = self.df.pid
self.add_new_infos(content)
pass
else:
hit, dmg, amg = event[1].split(',')
dmg = int(dmg)
amg = int(amg)
if event[0] is 1:
self.hp2 += dmg
self.hp1 -= amg
if hit is 'H':
content = "Heal by " + str(dmg) + ' Damage'
elif hit is 'C':
content = 'Critical Attack by ' + str(dmg) + ' Damage'
elif hit is 'M':
content = 'Miss'
color = (255, 0, 0, 255)
else:
content = 'oooops'
elif event[0] is 2:
color = (255, 255, 0, 255)
self.hp1 += dmg
self.hp2 -= amg
if hit is 'H':
content = "Counter by " + str(dmg) + ' Damage'
elif hit is 'C':
content = 'Critical Reflect by ' + str(dmg) + ' Damage'
elif hit is 'M':
content = 'Counter Miss'
color = (255, 0, 0, 255)
else:
content = 'oooops'
self.add_new_infos(content, color)
t1, a1 = self.attacker.set_angle_action(self.hp1 / self.mhp1)
t2, a2 = self.defender.set_angle_action(self.hp2 / self.mhp2)
t1.busy = t2.busy = True
t1.do(a1 + CallFunc(t1.parent.set_busy) +
CallFunc(self.get_next_action))
t2.do(a2 + CallFunc(t2.parent.set_busy) +
CallFunc(self.get_next_action))
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 __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 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 attack(self, battle_element):
at, df, wp, map, pos = battle_element
battle = Battle(at, df, wp, df.item[0], map, pos)
res = battle.battle()
del battle
obj = self.person[at.pid]
action = self._sequential_move(self.select, self.dst)
obj.do(action + CallFunc(self._battle_scene, res) + CallFunc(self.clear_map)
+ CallFunc(self.take_turn))
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 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( 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 _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, 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 __init__(self, back_team, front_team, location):
"""
:param back_team:
:type back_team: team.Team
:param front_team:
:type front_team: team.Team
:param location:
:type location: str
"""
Layer.__init__(self)
self.background_image = Sprite(pyglet.image.load(
resource.load_resource("bg-" + location + ".jpg", "BattleBackgrounds")),
position=(640/2, 480/2), scale=0.8)
self.add(self.background_image)
self.back_team = back_team
self.front_team = front_team
self.back_team.set_orientation(constants.BACK_FACING)
self.front_team.set_orientation(constants.FRONT_FACING)
self.back_team.add_to_battle(self)
self.front_team.add_to_battle(self)
self.add(self.front_team)
self.add(self.back_team)
self.animation_locked = False
self.toggle_animation_lock = CallFunc(self._toggle_animation_lock)
self.hud = BattleHUD(self)
self.add(self.hud)
def switch_pokemon(self, source_index, target_index):
if not self.current_battle:
raise RuntimeError("Trying to switch active pokemon when there is no battle active!")
elif self.current_battle.animation_locked:
return
source_pokemon = self.pokemon[source_index]
source_sprite = source_pokemon.get_sprite_for_orientation(self.orientation)
destination_pokemon = self.pokemon[target_index]
destination_sprite = destination_pokemon.get_sprite_for_orientation(self.orientation)
original_position = source_sprite.position
if self.orientation == constants.BACK_FACING:
switch_out = MoveTo((0, 0), duration=0.25)
else:
destination_sprite.position = (640, 480)
switch_out = MoveTo((640, 480), duration=0.25)
def switch_in():
destination_sprite.do(self.add_sprite +
MoveTo(original_position, duration=0.25) +
self.current_battle.toggle_animation_lock)
switch_in = CallFunc(switch_in)
source_sprite.do(switch_out + self.remove_sprite + switch_in)
self.current_battle.enable_animation_lock()
self.pokemon[target_index] = source_pokemon
self.pokemon[source_index] = destination_pokemon
self.current_battle.hud.update_health_bars()
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):
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 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 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 start_animation(self):
self.clean_skins()
self.animating = True
self.clean_control_points()
if self.user_skin:
skin = BitmapSkin(self.skeleton, self.user_skin)
else:
skin = ColorSkin(self.skeleton, (255, 255, 255, 255))
self.add(skin)
xs, ys = director.get_window_size()
skin.position = xs / 2 - 6, ys / 2 - 11
self.animation.move_start()
skin.do(
Animate(self.animation) + CallFunc(lambda: self.remove(skin)) +
CallFunc(self.stop_animation))
skin.do(UpdateTimeline(self.animation.get_duration()),
target=self.animation)
def excute(self, i=0):
if i < self.length:
_target, _action = self.actionlist[i] #type:CocosNode, Action
if _target is None:
_target = CocosNode()
_target.do(_action + CallFunc(self.excute, i+1))
else:
print('excuted')
def main():
show_common_text()
autoscale = True
if autoscale:
show_mode_1_text()
else:
show_mode_2_text()
director.init(view_width, view_height, autoscale=autoscale)
scene = TestScene()
world_layer = SquareLand(world_width, world_height)
scroller = cocos.layer.ScrollingManager()
if autotest:
def resize_scroller():
scroller.scale = 0.75
w, h = world_width, world_height
template_action = (
Delay(0.05) +
CallFunc(world_layer.teleport_player, 0, 0) + Delay(1) +
CallFunc(world_layer.teleport_player, w//2, 0) + Delay(1) +
CallFunc(world_layer.teleport_player, w//2, h) +Delay(1) +
CallFunc(world_layer.teleport_player, w, h) + Delay(1) +
CallFunc(resize_scroller) + Delay(1) +
CallFunc(director.window.set_size, 800, 600) + CallFunc(world_layer.update_after_change)
)
world_layer.do(template_action)
scroller.add(world_layer)
scene.add(scroller)
director.run(scene)
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 bar_raise(self, duration=3):
if self.bar.scale_x == 1:
self.bar.scale_x = 0
if self.i < self.level:
d = duration * (1 - self.bar.scale_x)
scale = 1
else:
scale = self.leftexp / 100
d = duration * (scale - self.bar.scale_x)
self.bar.do(Scale_to(scale_x=scale, scale_y=1, duration=d) + CallFunc(self.level_up))
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(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 __init__(self, name, pos):
if name == "unknown":
image = Image.unknown_brick
else:
image = Image.normal_brick
super().__init__(image)
self.position = pos
self.do(JumpBy((0, 0), 8, 1, 0.2) + CallFunc(self.kill))
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(Oneself, self).__init__()
self.position = (WIDTH / 2, 0 + 100)
self.sprite = Sprite('airplane_710px_1219057_easyicon.net.png',
scale=0.1)
self.add(self.sprite)
# self.cshape = cm.AARectShape(eu.Vector2(self.anchor_x, self.anchor_y), self.anchor_x, self.anchor_y)
fire = Repeat(Delay(0.2) + CallFunc(self.fire))
self.do(fire)
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 __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))
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, e):
super(EnemyObject, self).__init__(e[0].R.ENEMY[e[1]])
#X(axis)-Location for enemy
self.e = e
self.isDead = False
self.scale = 0.7
self.position = (director._window_virtual_width,
random.randint(30,director._window_virtual_height - 34 - self.height/2))
self.velocity = (-100, 0)
self.deadtemplate = Delay(0.5) + CallFunc(self.destroy)
self.do(Move())
#Collision Shape
self.cshape = CollisionModel.AARectShape(self.position, self.width/2, self.height/2)
