def __init__(self):
Layer.__init__(self)
self.config = Config()
self.gallery = Gallery()
self.schedule_interval(self.music_start, interval=7)
self.intro_sound = load("music/sound_start.wav", streaming=False)
self.intro_sound.play()
self.is_event_handler = True
background = Sprite(self.gallery.content["display"]["title"])
self.optimal_scale = (
self.config.window_width *
self.display_pos_size["display_title"]["W"]) / background.width
background.image_anchor = 0, 0
background.scale = self.optimal_scale
background.x = self.config.window_width * self.display_pos_size[
"display_title"]["X"]
background.y = self.config.window_height * self.display_pos_size[
"display_title"]["Y"]
self.left_margin = background.x
self.bottom_margin = background.y
self.optimal_width = background.width
self.optimal_height = background.height
self.add(background)
place_holder_image = Sprite(self.gallery.content["screen"]["title"])
place_holder_image.position = director.window.width / 2, director.window.height / 2
place_holder_image.scale = self.optimal_scale
place_holder_image.do(ScaleBy(5.2, duration=25))
self.add(place_holder_image)
def bring(self, minion):
if minion == "gatherer":
if self.gathval:
mini = Sprite(load_animation("resources/gatherer_coming.gif"),
position = (spawn_place[minion][0] + minion_move_to[minion][0],
spawn_place[minion][1] + minion_move_to[minion][1]))
mini.scale = minion_scale
self.add(mini)
mini.do(MoveTo(spawn_place[minion], minion_move_time) + CallFunc(mini.kill))
self.gathval = False
else:
mini1 = Sprite(load_animation("resources/gatherer.gif"), position = spawn_place[minion])
mini1.scale = minion_scale
self.add(mini1)
mini1.do(MoveBy(minion_move_to[minion], minion_move_time) + CallFunc(mini1.kill))
self.gathval = True
elif minion == "miner":
if self.minval:
mini = Sprite(load_animation("resources/miner.gif"),
position = (spawn_place[minion ][0] + minion_move_to[minion][0],
spawn_place[minion][1] + minion_move_to[minion][1]))
mini.scale = minion_scale
mini.scale_x = -minion_scale
self.add(mini)
mini.do(MoveTo( (spawn_place[minion]), minion_move_time) + CallFunc(mini.kill) )
self.minval = False
else:
mini1 = Sprite(load_animation("resources/miner.gif"), position = spawn_place[minion])
mini1.scale = minion_scale
self.add(mini1)
mini1.do(MoveBy(minion_move_to[minion], minion_move_time) + CallFunc(mini1.kill))
self.minval = True
def __init__(self):
super(Snake, self).__init__()
self.score = 30
self.head = Sprite('img/circle.png', color=random.choice(rand_color))
self.head.scale = 1.5
self.head.set_position(director.get_window_size()[0] / 2,
director.get_window_size()[1] / 2)
eyeball = Sprite('img/circle.png', color=(253, 55, 80))
eyeball.scale = 0.5
eye_left = Sprite('img/circle.png')
eye_left.y = 5
eye_left.scale = 0.5
eye_left.add(eyeball)
eye_right = Sprite('img/circle.png')
eye_right.y = -5
eye_right.scale = 0.5
eye_right.add(eyeball)
mouth = Sprite('img/circle.png', color=(0, 0, 0))
mouth.x = +5
mouth.scale = 0.3
self.head.add(mouth)
self.head.add(eye_left)
self.head.add(eye_right)
self.add(self.head)
self.schedule_interval(self.update, random.random() * 0.2 + 0.1)
def __init__(self):
super( TestLayer, self ).__init__()
x,y = director.get_window_size()
sprite1 = Sprite('grossini.png')
sprite1.position = x//4, y//2
self.add( sprite1 )
sprite2 = Sprite('grossini.png')
sprite2.position = x//4, y//2
self.add( sprite2, z=2 )
sprite2.scale = 0.3
sprite2.do( RotateBy(duration=2, angle=360) )
sprite1.do( RotateBy(duration=2, angle=-360) )
sprite1.transform_anchor = 0, 0
sprite3 = Sprite('grossini.png')
sprite3.position = 3*x//4, y//2
self.add( sprite3 )
sprite4 = Sprite('grossini.png')
sprite4.position = 3*x//4, y//2
self.add( sprite4, z=2 )
sprite4.scale = 0.3
sprite3.do( RotateBy(duration=2, angle=360) )
sprite4.do( RotateBy(duration=2, angle=-360) )
sprite3.transform_anchor = sprite3.image.width//2, sprite3.image.height//2
def _load_background(self):
background = Sprite(self.gallery.content["display"]["city_" +
self.market])
self.optimal_scale = (self.config.window_width *
self.display_pos_size["display_city_commerce"]
["W"]) / background.width
background.image_anchor = 0, 0
background.scale = self.optimal_scale
background.x = self.config.window_width * self.display_pos_size[
"display_city_commerce"]["X"]
background.y = self.config.window_height * self.display_pos_size[
"display_city_commerce"]["Y"]
self.left_margin = background.x
self.bottom_margin = background.y
self.optimal_width = background.width
self.optimal_height = background.height
self.add(background)
if self.market == "commerce":
overlay = Sprite(self.gallery.content["display"]["city_commerce_" +
self.supply])
overlay.image_anchor = 0, 0
overlay.x = self.left_margin
overlay.y = self.bottom_margin
overlay.scale = self.optimal_scale
self.add(overlay)
def __init__(self):
super(TestLayer, self).__init__()
x, y = director.get_window_size()
sprite1 = Sprite('grossini.png')
sprite1.position = x // 4, y // 2
self.add(sprite1)
sprite2 = Sprite('grossini.png')
sprite2.position = x // 4, y // 2
self.add(sprite2, z=2)
sprite2.scale = 0.3
sprite2.do(RotateBy(duration=2, angle=360))
sprite1.do(RotateBy(duration=2, angle=-360))
sprite1.transform_anchor = 0, 0
sprite3 = Sprite('grossini.png')
sprite3.position = 3 * x // 4, y // 2
self.add(sprite3)
sprite4 = Sprite('grossini.png')
sprite4.position = 3 * x // 4, y // 2
self.add(sprite4, z=2)
sprite4.scale = 0.3
sprite3.do(RotateBy(duration=2, angle=360))
sprite4.do(RotateBy(duration=2, angle=-360))
sprite3.transform_anchor = sprite3.image.width // 2, sprite3.image.height // 2
def __init__(self, game, interface, meta):
super().__init__(242, 242, 242, 255)
background_sprite = Sprite('fondo_final.svg', anchor=(0, 0))
background_sprite.position = (0, 0)
background_sprite.scale = 0.1
self.add(background_sprite, z=0)
self.game = game
self.toaster = None
self.meta = meta
self.meta["current_world"] = 0
self.current_screen = 0
self.space_used = 1
self.interface = interface
self.main_character = CollidableSprite('ppepotato.svg', anchor=(0, 0))
self.collision_manager = CollisionManagerBruteForce()
self.collision_manager.add(self.main_character)
self.add(self.main_character)
self.sprites_by_id = {}
self.explosions = []
self.do_draw()
self.schedule_interval(self.check_collisions, 0.1)
self.schedule_interval(self.check_finished, 0.1)
def _load_background(self):
background = Sprite(
self.gallery.content["display"]["worldmap_minitrain"])
self.optimal_scale = (self.config.window_width * self.display_pos_size[
"display_worldmap_minitrain"]["W"]) / background.width
background.image_anchor = 0, 0
background.scale = self.optimal_scale
background.x = self.config.window_width * self.display_pos_size[
"display_worldmap_minitrain"]["X"]
background.y = self.config.window_height * self.display_pos_size[
"display_worldmap_minitrain"]["Y"]
self.left_margin = background.x
self.bottom_margin = background.y
self.optimal_width = background.width
self.optimal_height = background.height
#self.add(background)
white_base = ColorLayer(255,
255,
255,
255,
width=background.width * 6,
height=background.height + 10)
white_base.x = background.x - (background.width * 3)
white_base.y = background.y + self.bottom_margin
self.add(white_base)
def _create_sprites(self):
SPEED = 0.4
logo_image = common.load_image('scene/intro/ceferino.png')
logo = Sprite(logo_image)
logo.scale = 4
logo.rotation = 180
logo.opacity = 0
logo.do(Place((100, 230)))
logo.do(Delay(SPEED / 2) +
(FadeIn(SPEED * 2) | RotateBy(180, SPEED) | ScaleTo(1, SPEED)))
losers_image = common.load_image('scene/intro/losers.png')
losers = Sprite(losers_image)
losers.position = 300, 500
losers.rotation = 180
losers.opacity = 0
losers.do(Delay(SPEED) +
(MoveTo((300, 250), SPEED) | FadeIn(SPEED) | RotateBy(180, SPEED)))
juegos_image = common.load_image('scene/intro/juegos.png')
juegos = Sprite(juegos_image)
juegos.position = 500, 0
juegos.rotation = -180
juegos.opacity = 0
juegos.do(Delay(SPEED/2 * 3) +
(MoveTo((520, 250), SPEED) | FadeIn(SPEED) | RotateBy(180, SPEED))
+ Delay(2) + CallFunc(self.skip_scene))
self.add(logo)
self.add(losers)
self.add(juegos)
self.juegos = juegos
def challenge(self, type, pos):
hunter = Sprite(load_animation("resources/" + type + ".gif"), position = (random.randint(483, 826), 105))
hunter.scale = minion_scale
self.add(hunter)
hunter.do(MoveTo(pos, minion_move_time))
return hunter
def _load_background(self):
background = Sprite(
self.gallery.content["display"]["worldmap_quarters"])
self.optimal_scale = (self.config.window_width * self.display_pos_size[
"display_worldmap_quarters"]["W"]) / background.width
background.image_anchor = 0, 0
background.scale = self.optimal_scale
background.x = self.config.window_width * self.display_pos_size[
"display_worldmap_quarters"]["X"]
background.y = self.config.window_height * self.display_pos_size[
"display_worldmap_quarters"]["Y"]
self.left_margin = background.x
self.bottom_margin = background.y
self.optimal_width = background.width
self.optimal_height = background.height
self.add(background)
self.ps_alarm = Sun()
self.ps_alarm.total_particles = 20
self.ps_alarm.speed = 0.0
self.ps_alarm.speed_var = 0.0
self.ps_alarm.life_var = 0.0
self.ps_alarm.blend_additive = True
self.ps_alarm.position = (
self.optimal_width * self.button_positions["ps_alarm"]["X"] +
self.left_margin), (
self.optimal_height * self.button_positions["ps_alarm"]["Y"] +
self.bottom_margin)
self.ps_alarm.start_color = Color(1, 0.40, 0.40, 0.40)
self.ps_alarm.size = 50.0
def _load_trade_boxes(self):
self.remove_trade_boxes()
if self.trade_display:
self._load_button_gen("button", "drop", events.emit_commerce_switch_trade_dump, "button_switch", 0, 1, 0.95)
for wagon in self.wagons_for_trade:
self._load_button_gen("wagon", self.config.conf_wagons[self.wagons_for_trade[wagon]["wagon_id"]].display_image+"_t", events.emit_wagon_select, "trade_bracket"+str(wagon), wagon, 1, 0.99 )
label_wagon_name = Label(self.config.conf_wagons[self.wagons_for_trade[wagon]["wagon_id"]].wagon_name + " ("+self.config.conf_wagons[self.wagons_for_trade[wagon]["wagon_id"]].storage+")", (self.optimal_width * (self.button_positions["sprite_trade_bracket"+str(wagon)]["X"]+0.112), self.optimal_height*(self.button_positions["sprite_trade_bracket"+str(wagon)]["Y"]+0.152)), color=(0,0,0,255), font_name="Arial", bold=True, font_size=16*self.optimal_scale, anchor_x="center", anchor_y="center")
self.add(label_wagon_name, name="trade_bracket_wagon_name"+str(wagon))
label_wagon_name = Label(" ", (self.optimal_width * (self.button_positions["sprite_trade_bracket"+str(wagon)]["X"]+0.112), self.optimal_height*(self.button_positions["sprite_trade_bracket"+str(wagon)]["Y"]+0.026)), color=(0,0,0,255), font_name="Arial", bold=True, font_size=14*self.optimal_scale, anchor_x="center", anchor_y="center")
self.add(label_wagon_name, name="trade_bracket_wagon_hold"+str(wagon))
self._load_button_gen("button", "plus", events.emit_item_buy, "button_buy"+str(wagon), wagon, 0.72, 0.95 )
self._load_button_gen("button", "minus", events.emit_item_sell, "button_sell"+str(wagon), wagon, 0.72, 0.95 )
else:
self._load_button_gen("button", "trade", events.emit_commerce_switch_trade_dump, "button_switch", 0, 1, 0.95)
for wagon in self.wagons_for_dump:
trade_bracket = Sprite(self.gallery.content["wagon"][self.config.conf_wagons[self.wagons_for_dump[wagon]["wagon_id"]].display_image+"_t"])
trade_bracket.image_anchor = 0, 0
trade_bracket.scale = self.optimal_scale
trade_bracket.x = self.optimal_width * self.button_positions["sprite_trade_bracket"+str(wagon)]["X"]
trade_bracket.y = self.optimal_height * self.button_positions["sprite_trade_bracket"+str(wagon)]["Y"]
self.add(trade_bracket, name="trade_bracket"+str(wagon))
label_wagon_name = Label(self.config.conf_wagons[self.wagons_for_dump[wagon]["wagon_id"]].wagon_name + " ("+self.config.conf_wagons[self.wagons_for_dump[wagon]["wagon_id"]].storage+")", (self.optimal_width * (self.button_positions["sprite_trade_bracket"+str(wagon)]["X"]+0.112), self.optimal_height*(self.button_positions["sprite_trade_bracket"+str(wagon)]["Y"]+0.152)), color=(0,0,0,255), font_name="Arial", bold=True, font_size=16*self.optimal_scale, anchor_x="center", anchor_y="center")
self.add(label_wagon_name, name="trade_bracket_wagon_name"+str(wagon))
label_wagon_name = Label(" ", (self.optimal_width * (self.button_positions["sprite_trade_bracket"+str(wagon)]["X"]+0.112), self.optimal_height*(self.button_positions["sprite_trade_bracket"+str(wagon)]["Y"]+0.026)), color=(0,0,0,255), font_name="Arial", bold=True, font_size=14*self.optimal_scale, anchor_x="center", anchor_y="center")
self.add(label_wagon_name, name="trade_bracket_wagon_hold"+str(wagon))
self._load_button_gen("button", "minus", events.emit_item_sell, "button_sell"+str(wagon), wagon, 0.72, 0.95 )
self.update_desc()
def __init__(self, piece, width, height):
super(PieceLayer, self).__init__()
self._width = width
self._height = height
self._piece = piece
#logging.debug('New piece layer %d x %d, image name %s' % (width, height, piece.imageName()))
# Pieces with the 'color' property get a background.
if hasattr(piece, 'color'):
#logging.debug('color ' + str(piece.color))
c = colors[piece.color]
bg = ColorLayer(c[0], c[1], c[2], 192, width=width, height=height)
self.add(bg)
self._background = bg
pieceSprite = Sprite(piece.imageName())
pieceSprite.image_anchor_x = 0
pieceSprite.image_anchor_y = 0
# Scale the sprite to the correct size.
rect = pieceSprite.get_rect()
scale = min(float(width) / rect.width,
float(height) / rect.height)
pieceSprite.scale = scale
self._pieceSprite = pieceSprite
self.add(pieceSprite)
self._opacity = 255
self._turnIndicator = None
self._updateTurnIndicator()
self._chargeIndicator = None
self._updateChargeIndicator()
def __init__(self, life=100, bullets=100):
super(HudLayer, self).__init__()
x, y = director.get_window_size()
self.bullets_ico = face = Sprite('hud/bullets.png')
self.bullets_ico.position = (
self.bullets_ico.image.width/2,
self.bullets_ico.image.height/2
)
self.bullets_label = cocos.text.Label(str(bullets),
font_name='Times New Roman',
font_size=32,
x=self.bullets_ico.image.width+10,
y=self.bullets_ico.image.height/2,
anchor_x='left', anchor_y='center')
self.add(self.bullets_ico)
self.add(self.bullets_label)
self.faces = {}
self.deads = []
space = 0
self.face_scale = scale = 0.7
for who in ["Dad", "Mom", "Zack", "Bee"]:
sprite = Sprite('faces/%s.png'%who)
self.faces[who] = sprite
sprite.scale = scale
sprite.position = (
x-space-sprite.image.width*scale/2,
sprite.image.height*scale/2
)
space += sprite.image.width*scale + 10
self.add(sprite)
def check_queue(self, dt=0):
width, height = cocos.director.director.get_window_size()
image = fetch_image()
sprite = Sprite(image)
sprite.rotation = random.randint(-25, 25)
end_scale = 1024.0 / image.width
sw = int((image.width * end_scale) / 2)
sh = int((image.height * end_scale) / 2)
sprite.x = random.randint(sw, width - sw)
sprite.y = random.randint(sh, height - sh)
sprite.opacity = 0
sprite.scale = end_scale * 1.5
sprite.do(
spawn(
FadeIn(.2),
AccelDeccel(ScaleTo(end_scale, duration=.4))) +
Delay(15) +
FadeOut(.5) +
CallFunc(sprite.kill))
self.z += 1
self.add(sprite, z=self.z)
def draw_info_army(self, cell):
"""Прорисовка окна информации армии"""
bg = Sprite("light95.png")
bg.scale_x = 0.5
bg.scale_y = 0.115
bg.position = [self.X_POS_ARMY, self.Y_POS]
self.mas_sprite.append(bg)
mas_shift = [-3, -1, 1, 3]
mas_count = [0]*4
for unit in cell.army.army:
for i in range(len(mas_count)):
if unit.type_unit == i+1:
mas_count[i] += unit.count
for i, g in enumerate(mas_shift):
unit = Sprite(self.IMAGE_NAME[i] + str(cell.army.player) + ".png")
unit.scale = 1.5
unit.position = [self.X_POS_ARMY + self.SHIFT*g - 20, self.Y_POS]
count = cocos.text.Label(str(mas_count[i]),
font_name='Times New Roman',
font_size=32,
anchor_x='left', anchor_y='center')
count.position = [self.X_POS_ARMY + self.SHIFT*g - 5, self.Y_POS]
self.mas_sprite.append(count)
self.mas_sprite.append(unit)
for object in self.mas_sprite:
chart.Chart().add(object)
def draw(self, flag):
if flag == 1:
'''Рисует окно'''
N = 3
window = Sprite("game_rule.png")
window.position = [self.X_WINDOW, self.Y_WINDOW]
window.scale = 0.8
self.mas_sprite = [window]
exit = Sprite("exit.png")
exit.position = [self.X_BTN, self.Y_BTN]
self.mas_sprite.append(exit)
self.mas_text = []
self.mas_test_pos = []
d = os.path.dirname(__file__)
interface = os.path.join(d, '../resources')
interface += '/' + 'rules.txt'
f = open(interface, 'r', encoding='utf-8')
x = 130
y = 650
for line in f:
label = cocos.text.Label(line,
font_name='Arial',
font_size=14,
anchor_x='left', anchor_y='center')
label.position = x, y
y -= 13
self.mas_sprite.append(label)
for object in self.mas_sprite:
chart.Chart().add(object)
def __init__(self):
super(SpriteMenuDocks, self).__init__()
sprite_menu_1 = Sprite('src/arts/in_game_menu_docks.png')
sprite_menu_1.scale = 2 / 3
size = cocos.director.director.get_window_size()
self.add(sprite_menu_1)
sprite_menu_1.position = size[0]*17/20, size[1]/2
def __init__(self):
super(MainLayer, self).__init__()
player = Sprite('sprites/Idle__000.png')
player.scale = 0.2
player.position = 120, 250
# player.do(MoveBy((450, 0), 3))
# player.do(Place((120, 400)))
# player.do(RotateBy(120,0))
# player.do(ScaleTo(1, 3))
# player.do(Blink(10, 3))
# player.do(Repeat(RotateBy(360, 1)))
# caminarDerecha = MoveBy((450, 0), 2)
# reiniciarPosicion = Place((120, 250))
# player.do(caminarDerecha + reiniciarPosicion)
# caminarDerecha = MoveBy((450, 0), 2)
# rotar = RotateBy(360, 1) * 2
# player.do(caminarDerecha | rotar)
# player.do(Blink(10, 3) + Show())
rotar = Repeat(RotateBy(360, 1))
achicar = ScaleTo(0, 2.5)
player.do(rotar | achicar)
self.add(player)
def bring(self, minion):
if minion == "gatherer":
if self.gathval:
mini = Sprite(load_animation("resources/gatherer_coming.gif"),
position=(spawn_place[minion][0] +
minion_move_to[minion][0],
spawn_place[minion][1] +
minion_move_to[minion][1]))
mini.scale = minion_scale
self.add(mini)
mini.do(
MoveTo(spawn_place[minion], minion_move_time) +
CallFunc(mini.kill))
self.gathval = False
else:
mini1 = Sprite(load_animation("resources/gatherer.gif"),
position=spawn_place[minion])
mini1.scale = minion_scale
self.add(mini1)
mini1.do(
MoveBy(minion_move_to[minion], minion_move_time) +
CallFunc(mini1.kill))
self.gathval = True
elif minion == "miner":
if self.minval:
mini = Sprite(load_animation("resources/miner.gif"),
position=(spawn_place[minion][0] +
minion_move_to[minion][0],
spawn_place[minion][1] +
minion_move_to[minion][1]))
mini.scale = minion_scale
mini.scale_x = -minion_scale
self.add(mini)
mini.do(
MoveTo((spawn_place[minion]), minion_move_time) +
CallFunc(mini.kill))
self.minval = False
else:
mini1 = Sprite(load_animation("resources/miner.gif"),
position=spawn_place[minion])
mini1.scale = minion_scale
self.add(mini1)
mini1.do(
MoveBy(minion_move_to[minion], minion_move_time) +
CallFunc(mini1.kill))
self.minval = True
def add_body(self):
b = Sprite('circle.png', color=self.color)
b.scale = 1.5
self.body.append(b)
if self.x == 0:
print self.position
b.position = self.position
self.parent.batch.add(b, 9999 - len(self.body))
def add_body(self):
b = Sprite('circle.png', color=self.color)
b.scale = 1.5
self.body.append(b)
if self.x == 0:
print self.position
b.position = self.position
self.parent.batch.add(b, 9999 - len(self.body))
def challenge(self, type, pos):
hunter = Sprite(load_animation("resources/" + type + ".gif"),
position=(random.randint(483, 826), 105))
hunter.scale = minion_scale
self.add(hunter)
hunter.do(MoveTo(pos, minion_move_time))
return hunter
def add_named_node(self,name,p0,color=(255,255,255)):
x,y = p0
b = Sprite('data/npoint.png',color=color)
b.x = x*scale+offset
b.y = y*scale+offset
b.scale = 1.0/8.0
self.add(b)
self.add_named(name,[b])
def __init__(self):
super(MainLayer, self).__init__()
player = Sprite('sprites/Idle__000.png')
player.scale = 0.2
player.position = 120, 250
self.add(player)
def invoke(self, minion):
mini = Sprite(load_animation("resources/" + minion + ".gif"),
position=spawn_place[minion])
mini.scale = minion_scale
self.add(mini)
mini.do(
MoveBy(minion_move_to[minion], minion_move_time) +
CallFunc(mini.kill))
def tile_sprite(self, tile_type, pos):
"""
:param tile_type: numeric id, must be in the range of available images
:param pos: sprite position
:return: sprite built form tile_type
"""
sprite = Sprite(tile_type)
sprite.position = pos
sprite.scale = 1
return sprite
def tile_sprite(self, tile_type, pos):
"""
:param tile_type: 数字ID必须在可用图像的范围内
:param pos:精灵的位置
:return: 根据tile_type编译精灵
"""
sprite = Sprite(tile_type)
sprite.position = pos
sprite.scale = 1
return sprite
def tile_sprite(self, tile_type, pos):
"""
:param tile_type: numeric id, must be in the range of available images
:param pos: sprite position
:return: sprite built form tile_type
"""
sprite = Sprite(tile_type)
sprite.position = pos
sprite.scale = 1
return sprite
def __init__(self, is_enemy=False): # 初始化并设置状态为玩家
super(Snake, self).__init__() # 初始化
self.is_dead = False # 初始化状态为存活
self.angle = random.randrange(360) # 目前角度
self.angle_dest = self.angle # 目标角度
self.color = random.choice(define.ALL_COLOR) # 随机颜色
if is_enemy: # 随机怪物位置
self.position = random.randrange(150,
650), random.randrange(100, 300)
if 300 < self.x < 500:
self.x += 200
else: # 随机玩家位置
self.position = random.randrange(350,
450), random.randrange(180, 230)
self.is_enemy = is_enemy # 传入状态
self.head = Sprite('circle.png', color=self.color) # 设置头的颜色
self.scale = 1.5 # 设置头的尺寸
eye = Sprite('circle.png') # 设置眼睛
eye.y = 5 # 设置眼睛的Y轴
eye.scale = 0.5 # 设置眼睛的尺寸
eyeball = Sprite('circle.png', color=define.BLACK) # 设置眼球的颜色
eyeball.scale = 0.5 # 设置眼球的尺寸
eye.add(eyeball) # 在眼睛中添加眼球
self.head.add(eye) # 在头中添加眼睛
eye = Sprite('circle.png') # 设置眼睛
eye.y = -5 # 设置眼睛的Y轴
eye.scale = 0.5 # 设置眼睛的尺寸
eyeball = Sprite('circle.png', color=define.BLACK) # 设置眼球的颜色
eyeball.scale = 0.5 # 设置眼球的尺寸
eye.add(eyeball) # 在眼睛中添加眼球
self.head.add(eye) # 设置眼睛
self.add(self.head) # 把头添加进身体
self.speed = 200 # 设置怪物速度
if not is_enemy: # 设置玩家速度
self.speed = 150
self.path = [self.position] * 100 # 用一个列表记录蛇头经过的位置，身子则根据路径中对应数据更新位置
self.schedule(self.update) # 在时间安排表中加入snake的更新
if self.is_enemy: # 更新怪物
self.schedule_interval(self.ai, random.random() * 0.1 + 0.05)
def __init__(self, is_enemy=False):
super(Snake, self).__init__()
self.is_dead = False
self.angle = random.randrange(360) # 目前角度
self.angle_dest = self.angle # 目标角度
self.color = random.choice(define.ALL_COLOR)
if is_enemy:
self.position = random.randrange(300,
1300), random.randrange(200, 600)
if 600 < self.x < 1000:
self.x += 400
else:
self.position = random.randrange(700,
900), random.randrange(350, 450)
self.is_enemy = is_enemy
self.head = Sprite('circle.png', color=self.color)
self.scale = 1.5
eye = Sprite('circle.png')
eye.y = 5
eye.scale = 0.5
eyeball = Sprite('circle.png', color=define.BLACK)
eyeball.scale = 0.5
eye.add(eyeball)
self.head.add(eye)
eye = Sprite('circle.png')
eye.y = -5
eye.scale = 0.5
eyeball = Sprite('circle.png', color=define.BLACK)
eyeball.scale = 0.5
eye.add(eyeball)
self.head.add(eye)
self.add(self.head)
self.speed = 150
if not is_enemy:
self.speed = 180
self.path = [self.position] * 100
self.schedule(self.update)
if self.is_enemy:
self.schedule_interval(self.ai, random.random() * 0.1 + 0.05)
def add_circle(self,center,radius):
cx , cy = center
sprites = []
for a in xrange(0, 360, 8):
b = Sprite('data/npoint.png')#,color=(140,140,140))
b.x = (cx + radius*cos(radians(a)))*scale+offset
b.y = (cy + radius*sin(radians(a)))*scale+offset
b.scale = 1.0/16.0
self.add(b)
sprites.append(b)
return sprites
def add_wpts(self,wpts):
sprites = []
for x,y in wps:
b = Sprite('data/npoint.png')#,color=(140,140,140))
b.x = x*scale+offset
b.y = y*scale+offset
b.scale = 1.0/8.0
self.add(b)
self.add_named('P%s %s'%(x,y),[b])
sprites.append(b)
return sprites
def __init__(self):
super( TestLayer, self ).__init__()
go_through = [(100,300), (370,330), (430,270), (750,550)]
# visually spot through where it should go
for pos in go_through:
sprite = Sprite('fire.png')
sprite.position = pos
sprite.scale = .3
self.add(sprite)
# calculate the points
bezier_path = direct_bezier(*go_through)
sprite = Sprite('fire.png')
sprite.scale = .3
sprite.color = (0, 0, 255)
self.add(sprite, z=5)
sprite.do(Bezier(bezier_path, 5))
def _load_background(self, bubble_type, px, py, pscale):
background = Sprite(self.gallery.content["text"]["bubble_" +
bubble_type])
background.scale = pscale
background.image_anchor = 0, 0
background.x = px
background.y = py
self.left_margin = background.x
self.bottom_margin = background.y
self.optimal_width = background.width
self.optimal_height = background.height
def __init__(self):
super(TestLayer, self).__init__()
go_through = [(100, 300), (370, 330), (430, 270), (750, 550)]
# visually spot through where it should go
for pos in go_through:
sprite = Sprite('fire.png')
sprite.position = pos
sprite.scale = .3
self.add(sprite)
# calculate the points
bezier_path = direct_bezier(*go_through)
sprite = Sprite('fire.png')
sprite.scale = .3
sprite.color = (0, 0, 255)
self.add(sprite, z=5)
sprite.do(Bezier(bezier_path, 5))
def __init__(self, game, interface, meta):
self.meta = meta
self.game = game
super().__init__(203, 207, 243, 255)
toaster_sprite = Sprite('moneda.svg')
toaster_sprite.scale = 0.5
toaster_sprite.position = (director.get_window_size()[0] / 2,
director.get_window_size()[1] / 2)
self.add(toaster_sprite)
self.has_ran = False
self.schedule_interval(self.run, 4)
def _load_background(self):
background = Sprite(self.gallery.content["display"]["city_hud"])
self.optimal_scale=(self.config.window_width * self.display_pos_size["display_city_hud"]["W"]) / background.width
background.image_anchor = 0, 0
background.scale = self.optimal_scale
background.x = self.config.window_width * self.display_pos_size["display_city_hud"]["X"]
background.y = self.config.window_height * self.display_pos_size["display_city_hud"]["Y"]
self.left_margin = background.x
self.bottom_margin = background.y
self.optimal_width = background.width
self.optimal_height = background.height
self.add(background)
def __init__(self, is_enemy=False):
super(Snake, self).__init__()
self.is_dead = False
self.angle = random.randrange(360) # 目前角度
self.angle_dest = self.angle # 目标角度
self.color = random.choice(define.ALL_COLOR)
if is_enemy:
self.position = random.randrange(300, 1300), random.randrange(200, 600)
if 600 < self.x < 1000:
self.x += 400
else:
self.position = random.randrange(700, 900), random.randrange(350, 450)
self.is_enemy = is_enemy
self.head = Sprite('circle.png', color=self.color)
self.scale = 1.5
eye = Sprite('circle.png')
eye.y = 5
eye.scale = 0.5
eyeball = Sprite('circle.png', color=define.BLACK)
eyeball.scale = 0.5
eye.add(eyeball)
self.head.add(eye)
eye = Sprite('circle.png')
eye.y = -5
eye.scale = 0.5
eyeball = Sprite('circle.png', color=define.BLACK)
eyeball.scale = 0.5
eye.add(eyeball)
self.head.add(eye)
self.add(self.head)
self.speed = 150
if not is_enemy:
self.speed = 180
self.path = [self.position] * 100
self.schedule(self.update)
if self.is_enemy:
self.schedule_interval(self.ai, random.random() * 0.1 + 0.05)
def eat_apple(self):
# create a new body and set the position to the previous last body partition
new_snake_body = Sprite('resources\\resized_body.png')
new_snake_body.position = self.body[-1].position
new_snake_body.scale = 0.05
# now, we can update the positions accordingly
self.add(new_snake_body)
self.body.append(new_snake_body)
self.problem.new_problem()
self.generate_apples()
self.score += 10
def menu_xo(self):
if not self.interact:
background = Sprite(
self.gallery.content["display"]["worldmap_hud_interact2"])
background.image_anchor = 0, 0
background.scale = self.optimal_scale
background.x = 0
background.y = 0
self.add(background, name="display_worldmap_hud_interact")
self.interact = True
opt = {
"0": {
"text": "Prospect for coal",
"param": "prospect"
},
"1": {
"text": "Deploy explosives",
"param": "mine"
},
"2": {
"text": "Discuss",
"param": "discuss_xo"
},
"3": {
"text": "That is all",
"param": "end"
}
}
display_interact_box_self = DisplayInteractBox(
opt, "1", self.optimal_width *
self.button_positions["display_interact_box_self"]["X"],
self.optimal_width *
self.button_positions["display_interact_box_self"]["Y"],
self.optimal_scale)
self.add(display_interact_box_self,
name="display_interact_box_self")
label_line_1 = self._load_label_gen("label_line_1")
self.add(label_line_1, name="label_line_1")
label_line_2 = self._load_label_gen("label_line_2")
self.add(label_line_2, name="label_line_2")
label_line_3 = self._load_label_gen("label_line_3")
self.add(label_line_3, name="label_line_3")
label_line_4 = self._load_label_gen("label_line_4")
self.add(label_line_4, name="label_line_4")
label_line_5 = self._load_label_gen("label_line_5")
self.add(label_line_5, name="label_line_5")
self.clear_text()
self.get("label_line_1"
).element.text = "Yes Conductor, how can I assist? "
def __init__(self, layer):
super(Light, self).__init__()
for c in layer.get_children():
sp = Sprite(c.image)
sp.source_position = c.position
sp.position = c.position
sp.scale = c.scale
sp.source_scale = c.scale
sp.rotation = c.rotation
sp.opacity = c.opacity
sp.dx = 0
sp.dy = 0
sp.dt = random.random()*3.15
self.add( sp )
def display_wagon_info(self, wagon):
try:
self.remove("sprite_wagon_selected")
except:
A=1
wagon_selected = Sprite(self.gallery.content["wagon"][self.config.conf_wagons[self.wagons_for_trade[wagon]["wagon_id"]].display_image+"_c"])
wagon_selected.image_anchor = 0, 0
wagon_selected.scale = self.optimal_scale*1.66
wagon_selected.x = self.optimal_width * self.button_positions["sprite_wagon_selected"]["X"]
wagon_selected.y = self.optimal_height * self.button_positions["sprite_wagon_selected"]["Y"]
self.add(wagon_selected, name="sprite_wagon_selected")
self.get("label_stores_1").element.text=self.config.conf_wagons[self.wagons_for_trade[wagon]["wagon_id"]].screen_name
self.get("label_stores_2").element.text="Net weight: "+self.config.conf_wagons[self.wagons_for_trade[wagon]["wagon_id"]].net_weight+", Capacity: "+self.config.conf_wagons[self.wagons_for_trade[wagon]["wagon_id"]].capacity+str(self.config.conf_wagons[self.wagons_for_trade[wagon]["wagon_id"]].units)+self.config.conf_wagons[self.wagons_for_trade[wagon]["wagon_id"]].storage
self.update_desc()
def __init__(self):
super(SpriteLayer, self).__init__()
sprite0 = Sprite('eleph2.png')
sprite1 = Sprite('eleph1.png')
sprite2 = Sprite('eleph0.png')
sprite0.position = (600, 360)
sprite1.position = (1180, 100)
sprite2.position = (20, 100)
sprite0.scale = .5
sprite1.scale = .5
sprite2.scale = .5
self.add(sprite0)
self.add(sprite1)
self.add(sprite2)
ju_right = JumpBy((600, 0), height=100, jumps=8, duration=5)
ju_left = JumpBy((-600, 0), height=100, jumps=8, duration=5)
rot1 = Rotate(180 * 4, duration=5)
sprite0.opacity = 128
sc = ScaleBy(9, 5)
rot = Rotate(180, 5)
sprite0.do(Repeat(sc + Reverse(sc)))
sprite0.do(Repeat(rot + Reverse(rot)))
sprite1.do(
Repeat(ju_left + ju_left + Reverse(ju_left) + Reverse(ju_left)))
sprite1.do(Repeat(Reverse(rot1) + Reverse(rot1) + rot1 + rot1))
sprite2.do(
Repeat(ju_right + ju_right + Reverse(ju_right) +
Reverse(ju_right)))
sprite2.do(Repeat(rot1 + rot1 + Reverse(rot1) + Reverse(rot1)))
def shootBullet(self):
if gVariables.g_IS_FX:
SFX(self.R._SFX[0])
bullet = Sprite(self.R._BULLET[gVariables.g_PlayerIndex])
bullet.position = (self.PLAYER.position[0] + bullet.width / 2,
self.PLAYER.position[1])
bullet.cshape = CollisionModel.AARectShape(bullet.position,
bullet.width / 2,
bullet.height / 2)
bullet.scale = 0.8
bullet.velocity = (self.bullet_speed, 0)
bullet.do(Move())
self.bullet_Lists.add(bullet)
self.collisionManager.add(bullet)
self.batch.add(bullet, self.bulletZ)
def add_line(self,p0,p1,color=(255,255,255)):
step = int(fstep*scale)
x0 , y0 = p0
x1 , y1 = p1
d = float(geom.dist(p0,p1))
a = fstep
sprites = []
while a<d:
b = Sprite('data/npoint.png', color=color)
b.x = (a*x0 + (d-a)*x1)*scale/d + offset
b.y = (a*y0 + (d-a)*y1)*scale/d + offset
b.scale = 1.0/16.0
self.add(b)
sprites.append(b)
a += fstep
return sprites
def _create_out_screenshot(self):
# TODO: try to use `pyglet.image.get_buffer_manager().get_color_buffer()`
# instead of create a new BufferManager... note that pyglet uses
# a BufferManager singleton that fail when you change the window
# size.
buffer = pyglet.image.BufferManager()
image = buffer.get_color_buffer()
width, height = director.window.width, director.window.height
actual_width, actual_height = director.get_window_size()
out = Sprite(image)
out.position = actual_width // 2, actual_height // 2
out.scale = max(actual_width / width, actual_height / height)
return out
def check_queue(self, dt=0):
width, height = cocos.director.director.get_window_size()
if self.bkg:
self.bkg.do(
CallFunc(self.bkg.kill)
)
image = fetch_image()
sprite = Sprite(image)
end_scale = 1024.0 / image.width * self.scale
sw = int((image.width * end_scale) / 2)
sh = int((image.height * end_scale) / 2)
if random.randint(0, 1):
sprite.x = 0
else:
sprite.x = width
sprite.y = random.randint(height * .25, height * .75)
#dst = random.randint(width*.25, width*.75), height / 2
dst = width / 2, height / 2
sprite.scale = end_scale * 5
sprite.opacity = 0
sprite.do(
spawn(
FadeIn(1),
AccelDeccel(
spawn(
ScaleTo(end_scale, duration=2),
MoveTo(dst, duration=2)))) +
Delay(self.interval) +
FadeOut(.5) +
CallFunc(sprite.kill))
self._z += 1
self.add(sprite, z=self._z)
def on_shoot(self, tower):
"""
when the tower shoots, add a shot sprite
"""
shot_sprite = Sprite('shot.png')
shot_sprite.scale = 0.5
self.shots_layer.add(shot_sprite, z=30)
ang_radians = math.radians(tower.angle)
x = math.sin(ang_radians)
y = math.cos(ang_radians)
shot_sprite.position = (self.x + self.shot_position * x,
self.y + self.shot_position * y)
shot_distance = tower.target_distance - self.shot_position
dx = (shot_distance) * x
dy = (shot_distance) * y
def remove_shot(shot):
self.shots_layer.remove(shot)
t = shot_distance / self.shot_speed_px
shot_sprite.do(MoveBy((dx, dy), t) +
CallFunc(remove_shot, shot_sprite))
def __init__(self):
super( TestLayer, self ).__init__()
x,y = director.get_window_size()
sprite = Sprite('grossini.png')
sprite.position = x//5, y//2
self.add(sprite)
sprite = Sprite('grossini.png')
sprite.position = x*2//5, y//2
sprite.scale_x = 0.5
self.add(sprite)
sprite = Sprite('grossini.png')
sprite.position = x*3//5, y//2
sprite.scale_y = 0.5
self.add(sprite)
sprite = Sprite('grossini.png')
sprite.position = x*4//5, y//2
sprite.scale_y = 0.5
sprite.scale = 2.0
self.add(sprite)
def __init__(self, battle_unit, is_friendly=True, reverse=False, mask_image=True, menu_selected=False):
super(UnitCard, self).__init__()
from board import Board
self.battle_unit = battle_unit
self.reverse = reverse
self.width = 0
self.height = 0
self.unit_display = BatchNode()
self.unit_display.position = 0, 0
mech_img_grid = pyglet.image.ImageGrid(pyglet.resource.image(battle_unit.getImagePath()), 1, 6)
mech_img_static = mech_img_grid[0]
pitch = -(mech_img_static.width * len('RGBA'))
img_data = mech_img_static.get_image_data()
pyg_img = mech_img_static
if mask_image:
# masking only a portion of the image based on damage
damage_height = int(mech_img_static.height)
data = img_data.get_region(0, 0, mech_img_static.width, damage_height).get_data('RGBA', pitch)
mask = Image.frombytes('RGBA', (mech_img_static.width, damage_height), data)
# the first image is the color that the stamp will be
img1 = Image.new('RGBA', mask.size, color=(0, 0, 0, 255))
# second image is the background
bg_color = (200, 75, 75, 200)
if is_friendly:
bg_color = (225, 225, 225, 200)
img2 = Image.new('RGBA', mask.size, color=bg_color)
img1 = img1.convert('RGBA')
# apply mask to background image
img = Image.composite(img1, img2, mask)
raw_image = img.tobytes()
img_x = mask.size[0]
img_y = mask.size[1]
pyg_img = pyglet.image.ImageData(img_x, img_y, 'RGBA', raw_image, pitch=-img_x * len('RGBA'))
mech_sprite = Sprite(pyg_img)
mech_sprite.position = mech_sprite.width // 2, Board.TILE_SIZE // 2 + mech_sprite.height // 2
self.sprite = mech_sprite
self.unit_display.add(mech_sprite)
self.add(self.unit_display)
# Show unit name above the image
unit_name_str = "%it %s [%ipv]" % (battle_unit.getTonnage(), battle_unit.getName(), battle_unit.getPointValue())
unit_name_font_size = Board.TILE_SIZE // 2
if menu_selected:
unit_name_font_size = int(unit_name_font_size * 1.5)
if reverse:
self.unit_name = floaters.TextFloater(unit_name_str, font_name='TranscendsGames',
font_size=unit_name_font_size, anchor_x='right', anchor_y='bottom')
name_rect = mech_sprite.get_rect().topright
self.unit_name.position = name_rect[0], name_rect[1]
else:
self.unit_name = floaters.TextFloater(unit_name_str, font_name='TranscendsGames',
font_size=unit_name_font_size, anchor_x='left', anchor_y='bottom')
name_rect = mech_sprite.get_rect().topleft
self.unit_name.position = name_rect[0], name_rect[1]
self.add(self.unit_name)
# Show unit variant below the image
unit_variant_str = battle_unit.getVariant().upper()
unit_variant_font_size = Board.TILE_SIZE // 3
if menu_selected:
unit_variant_font_size = int(unit_variant_font_size * 1.5)
if reverse:
self.unit_variant = floaters.TextFloater(unit_variant_str, font_name='TranscendsGames',
font_size=unit_variant_font_size, anchor_x='right', anchor_y='top')
variant_rect = mech_sprite.get_rect().bottomright
self.unit_variant.position = variant_rect[0], variant_rect[1] - 4
else:
self.unit_variant = floaters.TextFloater(unit_variant_str, font_name='TranscendsGames',
font_size=unit_variant_font_size, anchor_x='left', anchor_y='top')
variant_rect = mech_sprite.get_rect().bottomleft
self.unit_variant.position = variant_rect[0], variant_rect[1] - 4
if menu_selected:
# when selected in a menu the fonts are larger and needs more space away from the image stamp
self.unit_variant.y -= unit_variant_font_size
self.add(self.unit_variant)
# Show armor, structure, heat stats next to the image (top)
unit_stats = cocos.layer.Layer()
stats_width = 0
stats_height = 0
# Show move and attack numbers next to the image (bottom)
# values = "MV %i ATK %i/%i/%i" % (battle_unit.getTurnMove(),
# battle_unit.short, battle_unit.medium, battle_unit.long)
# self.unit_values = floaters.TextFloater(values, font_name='TranscendsGames',
# font_size=Board.TILE_SIZE // 4, anchor_x='left', anchor_y='bottom')
# values_pos = mech_sprite.get_rect().bottomright
# self.unit_values.position = 4 + values_pos[0], values_pos[1] - 2
# self.add(self.unit_values)
# create move icon and label of values
move_icon = Sprite(Resources.move_icon_img)
move_str = str(battle_unit.getTurnMove())
unit_values_font_size = Board.TILE_SIZE // 3
if menu_selected:
unit_values_font_size = int(unit_values_font_size * 1.25)
if reverse:
move_icon.position = -move_icon.width // 2, stats_height + move_icon.height // 2
move_label = floaters.TextFloater(move_str, font_name='TranscendsGames',
font_size=unit_values_font_size, anchor_x='right', anchor_y='bottom')
move_label.position = move_icon.get_rect().bottomleft
unit_stats.add(move_label, z=2)
else:
move_icon.position = move_icon.width // 2, stats_height + move_icon.height // 2
move_label = floaters.TextFloater(move_str, font_name='TranscendsGames',
font_size=unit_values_font_size, anchor_x='left', anchor_y='bottom')
move_label.position = move_icon.get_rect().bottomright
unit_stats.add(move_label, z=2)
unit_stats.add(move_icon, z=2)
stats_height += move_icon.height
# create attack icon and label of values
attack_icon = Sprite(Resources.weapon_icon_img)
attack_short = battle_unit.getDamageForRange('short')
attack_medium = battle_unit.getDamageForRange('medium')
attack_long = battle_unit.getDamageForRange('long')
attack_str = "%i/%i/%i" % (attack_short, attack_medium, attack_long)
if reverse:
attack_icon.position = -attack_icon.width // 2, stats_height + attack_icon.height // 2
attack_label = floaters.TextFloater(attack_str, font_name='TranscendsGames',
font_size=unit_values_font_size, anchor_x='right', anchor_y='bottom')
attack_label.position = attack_icon.get_rect().bottomleft
unit_stats.add(attack_label, z=2)
else:
attack_icon.position = attack_icon.width // 2, stats_height + attack_icon.height // 2
attack_label = floaters.TextFloater(attack_str, font_name='TranscendsGames',
font_size=unit_values_font_size, anchor_x='left', anchor_y='bottom')
attack_label.position = attack_icon.get_rect().bottomright
unit_stats.add(attack_label, z=2)
unit_stats.add(attack_icon, z=2)
stats_height += attack_icon.height
# create heat icon and bars
heat_icon = Sprite(Resources.heat_icon_img)
if reverse:
heat_icon.position = -heat_icon.width // 2, stats_height + heat_icon.height // 2
else:
heat_icon.position = heat_icon.width // 2, stats_height + heat_icon.height // 2
unit_stats.add(heat_icon, z=2)
for i in range(battle_unit.heat):
pip = Sprite(Resources.heat_pip_img)
pip.scale = 2.0
if reverse:
pip.position = -heat_icon.width - (i * pip.width) - pip.width, stats_height + pip.height // 2
else:
pip.position = heat_icon.width + (i * pip.width) + pip.width // 2, stats_height + pip.height // 2
unit_stats.add(pip, z=1)
if pip.x + pip.width > stats_width:
stats_width = pip.x + pip.width
stats_height += heat_icon.height
# create structure icon and bars
structure_icon = Sprite(Resources.structure_icon_img)
if reverse:
structure_icon.position = -structure_icon.width // 2, stats_height + structure_icon.height // 2
else:
structure_icon.position = structure_icon.width // 2, stats_height + structure_icon.height // 2
unit_stats.add(structure_icon, z=2)
orig_structure = battle_unit.mech.structure
for i in range(orig_structure):
pip_img = Resources.structure_pip_img
if i >= battle_unit.structure:
pip_img = Resources.empty_pip_img
pip = Sprite(pip_img)
pip.scale = 2.0
if reverse:
pip.position = -structure_icon.width - (i * pip.width) - pip.width, stats_height + pip.height // 2
else:
pip.position = structure_icon.width + (i * pip.width) + pip.width // 2, stats_height + pip.height // 2
unit_stats.add(pip, z=1)
if pip.x + pip.width > stats_width:
stats_width = pip.x + pip.width
stats_height += structure_icon.height
# create armor icon and bars
armor_icon = Sprite(Resources.armor_icon_img)
if reverse:
armor_icon.position = -armor_icon.width // 2, stats_height + armor_icon.height // 2
else:
armor_icon.position = armor_icon.width // 2, stats_height + armor_icon.height // 2
unit_stats.add(armor_icon, z=2)
orig_armor = battle_unit.mech.armor
for i in range(orig_armor):
pip_img = Resources.armor_pip_img
if i >= battle_unit.armor:
pip_img = Resources.empty_pip_img
pip = Sprite(pip_img)
pip.scale = 2.0
if reverse:
pip.position = -armor_icon.width - (i * pip.width) - pip.width, stats_height + pip.height // 2
else:
pip.position = armor_icon.width + (i * pip.width) + pip.width // 2, stats_height + pip.height // 2
unit_stats.add(pip, z=1)
if pip.x + pip.width > stats_width:
stats_width = pip.x + pip.width
stats_height += armor_icon.height
if reverse:
stats_pos = mech_sprite.get_rect().topleft
unit_stats.position = stats_pos[0] - 4, stats_pos[1] - stats_height
else:
stats_pos = mech_sprite.get_rect().topright
unit_stats.position = 4 + stats_pos[0], stats_pos[1] - stats_height
self.add(unit_stats)
# calculate actual width and height of this element
self.width = mech_sprite.width + stats_width
self.height = mech_sprite.height + (3 * Board.TILE_SIZE // 2)
def add_image_sprite(self):
print("ImageLayer.add_image_layer()")
pil = PIL.Image.open(self.image_file)
pyglet_img = pyglet.image.load(self.image_file)
target_w = self.window_width
target_h = self.window_height
orig_w = pil.size[0]
orig_h = pil.size[1]
id = self.next_id
print(pil)
( xscale, yscale,
result_w, result_h, dx, dy ) = SizeFitting.scaleToSize(
orig_w, orig_h,
target_w, target_h,
FitType.ScaleFitAspectFit)
imgsprite = Sprite(pyglet_img)
imgsprite.anchor = (0, 0)
imgsprite.transform_anchor = (result_w/2, result_h/2)
bg_w = int(float(target_w) / xscale)
bg_h = int(float(target_h) / yscale)
background = SolidColorImagePattern(
color=self.color_black
).create_image(width=bg_w, height=bg_h)
bgsprite = Sprite(background)
bgsprite.add(imgsprite, z=id, name="image%d" % id)
bgsprite.anchor = (0, 0)
bgsprite.scale = xscale
self.add(bgsprite, z=id, name="spritelayer%d" % id)
self.animate(bgsprite, imgsprite)
## !!! CENTERING !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
self.position = (target_w/2, target_h/2)
## Remove the lign below to center on display (as oppposed to anchoing at (0,0)
# imgsprite.position = (-(target_w-result_w)/2/xscale, -(target_h-result_h)/2/yscale )
## !!!!!!!!!!!!!!
##############
########## DEBUG
bg = bgsprite
lists = [ "orig_w result_w bg_w target_w xscale".split(" "),
"orig_h result_h bg_h target_h yscale".split(" "),
"bg.width bg.height bg.anchor bg.transform_anchor".split(" "),
"self.position self.get_local_transform() self.get_world_transform()".split(" ")
]
debug = "id: %2d " %id
for list in lists:
debug += "\n"
for key in list:
debug += "{k:>5}: {v:>4} ".format(k=key, v=eval(key))
print debug
def invoke(self, minion):
mini = Sprite(load_animation("resources/" + minion + ".gif"), position = spawn_place[minion])
mini.scale = minion_scale
self.add(mini)
mini.do(MoveBy(minion_move_to[minion], minion_move_time) + CallFunc(mini.kill))
def performAttackOnUnit(board, target_unit, overheat=0):
# perform an attack on the given target BattleUnit
battle = board.battle
turn_unit = battle.getTurnUnit()
if turn_unit is None or target_unit is None\
or turn_unit.isDestroyed() or target_unit.isDestroyed():
# TODO: make sure it is a player unit's turn
return 0
src_cell = turn_unit.col, turn_unit.row
dest_cell = target_unit.col, target_unit.row
# minimum travel time to target used to determine when to show the damage floater
min_travel_time = 0
# maximum travel time to target used to determine when all animations are finished
max_travel_time = 0
# cell distance used to determine which range of weapons will fire
cell_distance = Battle.getCellDistance(src_cell, dest_cell)
target_range = Battle.getDistanceRange(cell_distance)
print(target_range + ": " + str(src_cell) + " -> " + str(dest_cell) + " = " + str(cell_distance))
# perform the attack and show the results
attack_results = battle.performAttack(turn_unit, target_unit, overheat=overheat)
attack_damage = attack_results.attack_damage
critical_type = attack_results.critical_type
# determine actual target point based on the target unit sprite size
target_sprite = target_unit.getSprite()
real_x = (dest_cell[0] * Board.TILE_SIZE) + Board.TILE_SIZE // 2
real_y = (dest_cell[1] * Board.TILE_SIZE) + (2 * target_sprite.get_height() // 3)
# if missed, show a visible weapon miss
if attack_damage == 0:
real_x += random.choice([-1, 1]) * Board.TILE_SIZE
real_y += random.choice([-1, 0, 1]) * Board.TILE_SIZE
for weaponMap in turn_unit.mech.weapons:
for weapon in weaponMap.iterkeys():
if not weapon.inRange(cell_distance):
continue
weapon_data = weaponMap[weapon]
# get sound channel to use just for this weapon
weapon_channel = pygame.mixer.find_channel()
if weapon_channel is None:
weapon_channel = pygame.mixer.Channel(0)
weapon_channel.set_volume(Settings.get_volume_fx())
weapon_offset = weapon_data.get('offset', [0, 0])
weapon_x = turn_unit.sprite.x + weapon_offset[0]
weapon_y = turn_unit.sprite.y - (Board.TILE_SIZE // 2) + weapon_offset[1]
weapon_color = weapon.get_color()
if weapon.isPPC():
# fire test ppcs
ppc = Meteor()
ppc.size = 10
ppc.speed = 20
ppc.gravity = Point2(0, 0)
# TODO: offer decreased particle emission rate to improve performance
ppc.emission_rate = 100
ppc.life = 0.5
ppc.life_var = 0.1
ppc.position = weapon_x, weapon_y
board.add(ppc, z=1000)
target_x = real_x + random_offset()
target_y = real_y + random_offset()
target_pos = target_x, target_y
# figure out the duration based on speed and distance
ppc_speed = weapon.get_speed() # pixels per second
distance = Point2(ppc.x, ppc.y).distance(Point2(target_x, target_y))
ppc_t = distance / ppc_speed
ppc_sound = Resources.ppc_sound
weapon_channel.play(ppc_sound)
action = Delay(0.5) + MoveTo((target_x, target_y), duration=ppc_t) \
+ CallFunc(impact_ppc, ppc) \
+ Delay(0.5) + CallFunc(ppc.kill) \
+ Delay(ppc_sound.get_length()) \
+ CallFunc(weapon_channel.stop)
ppc.do(action)
travel_time = 0.5 + ppc_t
if min_travel_time == 0 or min_travel_time > travel_time:
min_travel_time = travel_time
if travel_time > max_travel_time:
max_travel_time = travel_time
elif weapon.isFlamer():
# fire test flamer
flamer = Fire()
flamer.size = 25
flamer.speed = 300
flamer.gravity = Point2(0, 0)
# TODO: offer decreased particle emission rate to improve performance
flamer.emission_rate = 100
dx = real_x - weapon_x
dy = real_y - weapon_y
rads = atan2(-dy, dx)
rads %= 2 * pi
angle = degrees(rads) + 90
flamer.rotation = angle
flamer.angle_var = 5
flamer.pos_var = Point2(5, 5)
flamer.position = weapon_x, weapon_y
board.add(flamer, z=1000)
target_x = real_x + random_offset()
target_y = real_y + random_offset()
target_pos = target_x, target_y
# figure out the duration based on speed and distance
flamer_speed = weapon.get_speed() # pixels per second
distance = Point2(flamer.x, flamer.y).distance(Point2(target_x, target_y))
flamer_t = 1
flamer.life = distance / flamer_speed
flamer.life_var = 0
flamer_sound = Resources.flamer_sound
weapon_channel.play(flamer_sound)
action = Delay(flamer_t) \
+ CallFunc(impact_flamer, flamer) \
+ CallFunc(weapon_channel.fadeout, 750) \
+ Delay(flamer_t) + CallFunc(flamer.kill) \
+ CallFunc(weapon_channel.stop)
flamer.do(action)
travel_time = flamer_t
if min_travel_time == 0 or min_travel_time > travel_time:
min_travel_time = travel_time
if travel_time > max_travel_time:
max_travel_time = travel_time
elif weapon.isLaser():
# fire test laser
las_life = 1.0
las_size = (1, 1, 1)
if weapon.isShort():
las_size = (2, 1, 0.5)
las_life = 0.5
elif weapon.isMedium():
las_size = (3, 2, 1)
las_life = 0.75
elif weapon.isLong():
las_size = (6, 4, 2)
las_life = 1.0
target_x = real_x + random_offset()
target_y = real_y + random_offset()
target_pos = target_x, target_y
las_outer = gl.SingleLine((weapon_x, weapon_y), (target_x, target_y),
width=las_size[0],
color=(weapon_color[0], weapon_color[1], weapon_color[2], 50))
las_middle = gl.SingleLine((weapon_x, weapon_y), (target_x, target_y),
width=las_size[1],
color=(weapon_color[0], weapon_color[1], weapon_color[2], 125))
las_inner = gl.SingleLine((weapon_x, weapon_y), (target_x, target_y),
width=las_size[2],
color=(weapon_color[0], weapon_color[1], weapon_color[2], 200))
las_outer.visible = False
las_middle.visible = False
las_inner.visible = False
node = cocos.layer.Layer()
node.add(las_outer, z=1)
node.add(las_middle, z=2)
node.add(las_inner, z=3)
board.add(node, z=1000)
# give lasers a small particle pre-fire effect
laser_charge = Galaxy()
laser_charge.angle = 270
laser_charge.angle_var = 180
laser_charge.position = weapon_x, weapon_y
laser_charge.size = 10
laser_charge.size_var = 5
laser_charge.emission_rate = 15
laser_charge.life = 0.5
laser_charge.speed = 0
laser_charge.speed_var = 0
laser_charge.start_color = Color(weapon_color[0] / 255, weapon_color[1] / 255, weapon_color[2] / 255,
1.0)
laser_charge.end_color = Color(weapon_color[0] / 255, weapon_color[1] / 255, weapon_color[2] / 255, 1.0)
node.add(laser_charge, z=0)
laser_drift = random.uniform(-15.0, 15.0), random.uniform(-15.0, 15.0)
las_action = Delay(0.5) + ToggleVisibility() \
+ CallFunc(create_laser_impact, board, target_pos, laser_drift, las_life) \
+ gl.LineDriftBy(laser_drift, las_life) \
+ CallFunc(laser_charge.stop_system) + CallFunc(node.kill)
las_outer.do(las_action)
las_middle.do(las_action)
las_inner.do(las_action)
las_sound = Resources.las_sound
weapon_channel.play(las_sound)
las_duration_ms = int(las_action.duration * 1000)
weapon_channel.fadeout(las_duration_ms)
travel_time = 0.5
if min_travel_time == 0 or min_travel_time > travel_time:
min_travel_time = travel_time
if travel_time > max_travel_time:
max_travel_time = travel_time
elif weapon.isBallistic():
# fire test ballistic projectile
num_ballistic = weapon.get_projectiles()
if weapon.isGauss():
ballistic_img = Resources.gauss_img
elif weapon.isLBX():
# LBX fires only one projectile, but will appear to have multiple random impacts
num_ballistic = 1
ballistic_img = Resources.buckshot_img
else:
ballistic_img = Resources.ballistic_img
# machine gun sound only plays once instead of per projectile
cannon_sound = None
if weapon.isMG():
cannon_sound = Resources.machinegun_sound
elif weapon.isGauss():
cannon_sound = Resources.gauss_sound
for i in range(num_ballistic):
ballistic = Sprite(ballistic_img)
ballistic.visible = False
ballistic.position = weapon_x, weapon_y
ballistic.scale = weapon.get_scale()
ballistic.anchor = 0, 0
dx = real_x - weapon_x
dy = real_y - weapon_y
rads = atan2(-dy, dx)
rads %= 2 * pi
angle = degrees(rads)
ballistic.rotation = angle
target_x = real_x + random_offset()
target_y = real_y + random_offset()
target_pos = target_x, target_y
# figure out the duration based on speed and distance
ballistic_speed = weapon.get_speed() # pixels per second
distance = Point2(weapon_x, weapon_y).distance(Point2(target_x, target_y))
ballistic_t = distance / ballistic_speed
# setup the firing sound
if cannon_sound is None:
cannon_sound = Resources.cannon_sound
impact_func = create_ballistic_impact
if weapon.isLBX():
impact_func = create_lbx_impact
action = Delay(i * 0.1) + ToggleVisibility() \
+ CallFunc(weapon_channel.play, cannon_sound) \
+ MoveTo((target_x, target_y), ballistic_t) \
+ CallFunc(impact_func, weapon, board, target_pos) \
+ CallFunc(ballistic.kill)
if weapon.isGauss():
# give gauss sound a bit more time to stop
action += Delay(cannon_sound.get_length())
if i == num_ballistic - 1:
# stop the sound channel after the last projectile only
action += CallFunc(weapon_channel.stop)
ballistic.do(action)
board.add(ballistic, z=1000 + i)
travel_time = (i * 0.1) + ballistic_t
if min_travel_time == 0 or min_travel_time > travel_time:
min_travel_time = travel_time
if travel_time > max_travel_time:
max_travel_time = travel_time
elif weapon.isMissile():
# get another sound channel to use just for the explosions
explosion_channel = pygame.mixer.find_channel()
if explosion_channel is None:
explosion_channel = pygame.mixer.Channel(1)
explosion_channel.set_volume(Settings.get_volume_fx())
# fire test missile projectile
missile_img = Resources.missile_img
num_missile = weapon_data.get('count', 1)
num_per_row = 1
if weapon.isLRM():
num_per_row = 5
elif weapon.isSRM():
num_per_row = 2
for i in range(num_missile):
tube_x = i % num_per_row
tube_y = i // num_per_row
missile = Sprite(missile_img)
missile.visible = False
missile.position = weapon_x + tube_x, weapon_y + tube_y
missile.scale = weapon.get_scale()
missile.anchor = 0, 0
dx = real_x - weapon_x
dy = real_y - weapon_y
rads = atan2(-dy, dx)
rads %= 2 * pi
angle = degrees(rads)
missile.rotation = angle
target_x = real_x + random_offset()
target_y = real_y + random_offset()
target_pos = target_x, target_y
# figure out the duration based on speed and distance
missile_speed = weapon.get_speed() # pixels per second
distance = Point2(weapon_x, weapon_y).distance(Point2(target_x, target_y))
missile_t = distance / missile_speed
rand_missile_sound = random.randint(0, 7)
missile_sound = Resources.missile_sounds[rand_missile_sound]
explosion_sound = Resources.impact_sound
action = Delay(i * 0.05) + ToggleVisibility() \
+ CallFunc(weapon_channel.play, missile_sound) \
+ MoveTo((target_x, target_y), missile_t) \
+ CallFunc(create_missile_impact, board, target_pos) \
+ CallFunc(missile.kill) \
+ CallFunc(explosion_channel.play, explosion_sound) \
+ Delay(0.5)
if i == num_missile - 1:
# stop the sound channels after the last missile only
action += CallFunc(weapon_channel.stop) + CallFunc(explosion_channel.stop)
missile.do(action)
board.add(missile, z=1000 + i)
travel_time = (i * 0.05) + missile_t
if min_travel_time == 0 or min_travel_time > travel_time:
min_travel_time = travel_time
if travel_time > max_travel_time:
max_travel_time = travel_time
# scroll focus over to the target area halfway through the travel time
target_area = Board.board_to_layer(target_unit.col, target_unit.row)
# show damage floater after the travel time of the first projectile to hit
floater_text = "%i" % attack_damage
if attack_damage == 0:
floater_text = "MISS"
floater = floaters.TextFloater(floater_text)
floater.visible = False
floater.position = real_x, real_y + target_sprite.get_height() // 3
board.add(floater, z=2000)
action = Delay(min_travel_time / 2) + CallFunc(board.scroller.set_focus, *target_area) \
+ Delay(min_travel_time / 2) + ToggleVisibility() \
+ Delay(0.25) + MoveBy((0, Board.TILE_SIZE), 1.0) \
+ FadeOut(1.0) + CallFunc(floater.kill)
floater.do(action)
if critical_type is not None:
crit_floater = floaters.TextFloater(critical_type)
crit_floater.visible = False
crit_floater.position = real_x, real_y + target_sprite.get_height() // 3
board.add(crit_floater, z=2000)
action = Delay(min_travel_time) + Delay(1.0) + ToggleVisibility() \
+ Delay(0.25) + MoveBy((0, Board.TILE_SIZE), 1.5) \
+ FadeOut(1.5) + CallFunc(crit_floater.kill)
crit_floater.do(action)
if action.duration > max_travel_time:
max_travel_time = action.duration
stats_action = Delay(min_travel_time) + CallFunc(target_sprite.updateStatsIndicators) \
+ CallFunc(Interface.UI.updateTargetUnitStats, target_unit)
target_sprite.do(stats_action)
if target_unit.structure > 0:
print("Remaining %i/%i" % (target_unit.armor, target_unit.structure))
else:
print("Target destroyed!")
# show destroyed floater after the travel time of the first projectile to hit
destroyed = floaters.TextFloater("DESTROYED")
destroyed.visible = False
destroyed.position = real_x, real_y + target_sprite.get_height() // 3
board.add(destroyed, z=5000)
action = Delay(max_travel_time) + ToggleVisibility() \
+ (MoveBy((0, Board.TILE_SIZE), 1.0) | CallFunc(create_destruction_explosions, board, target_unit)) \
+ Delay(0.5) + CallFunc(target_sprite.destroy) + FadeOut(2.0) + CallFunc(destroyed.kill)
destroyed.do(action)
# give a bit of extra time to explode
max_travel_time = action.duration
return max_travel_time
