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, battle): super(Board, self).__init__() Board.BOARD = self self.scroller = None self.battle = battle self.map = battle.map self.cellMap = {} # add basic ground cell tiles ground_img = Resources.ground_img node = BatchNode() self.add(node, z=0) for row in range(self.map.numRows): for col in range(self.map.numCols): tile = self.map.getTileAt(col, row) cell = Cell(tile, ground_img) rect = cell.get_rect() rect.bottomleft = col * 32, row * 32 cell.position = rect.center node.add(cell, z=0) self.cellMap[(col, row)] = cell # add terrain feature/building cell tiles for col, row in self.map.boardMap: loc = (col, row) cell_data = self.map.boardMap[loc] cell_images = cell_data.images if cell_images is not None: cell_level = cell_data.level cell_z = (self.map.numCols - row - cell_level) * 10 cell_batch = BatchNode() cell_batch.position = col * self.TILE_SIZE, row * self.TILE_SIZE self.add(cell_batch, z=cell_z) cell_cols = cell_data.cols cell_rows = cell_data.rows for this_row in range(cell_rows + cell_level): for this_col in range(cell_cols): cell_index = this_col + (this_row * cell_cols) cell_sprite = Sprite(cell_images[cell_index]) cell_rect = cell_sprite.get_rect() cell_rect.bottomleft = this_col * self.TILE_SIZE, this_row * self.TILE_SIZE cell_sprite.position = cell_rect.center cell_batch.add(cell_sprite)
def update_blocks(self): '''更新砖块''' b = Sprite('images/block.png', anchor=(0, 0)) b.position = (self.mouse_x, self.mouse_y) r = b.get_rect() for x, y in self.postmp: bx = x + b.width by = y + b.height if r.contains(bx, by): if (x, y) not in self.pos: self.press_left(x, y, b) else: self.press_right(x, y, b) break
class BackgroundLayer(Layer): """ Layer that holds the absolute bottom background layer """ def __init__(self): """ Create a BackgroundLayer """ super().__init__() self.sprite = Sprite('/'.join( ["assets", "textures", "environment", "background.png"])) self.sprite.position = 0, 0 self.add(self.sprite) width = config.screen_size[0] height = config.screen_size[1] rect = self.sprite.get_rect() self.sprite.image_anchor = rect.center self.sprite.scale_x = width / rect.width self.sprite.scale_y = height / rect.height
def __init__(self, battle_mech): super(MechSprite, self).__init__() self.battle_mech = battle_mech mech_img = pyglet.resource.image(self.battle_mech.getImagePath()) mech_img_grid = pyglet.image.ImageGrid(mech_img, 1, 6) self.static = True img_static = Sprite(mech_img_grid[0]) self.width = img_static.width self.height = img_static.height # TODO: setup the non square friendly/enemy indicators based on team of current player's turn if battle_mech.player.is_bot: indicator = Sprite(Resources.enemy_indicator_img) else: indicator = Sprite(Resources.friendly_indicator_img) indicator.visible = False indicator.position = 0, -img_static.height // 2 + indicator.height // 2 + 1 self.indicator = indicator self.add(indicator, z=0) shadow = Sprite(MechSprite.shadow_img_grid[battle_mech.getSize() - 1]) shadow_rect = shadow.get_rect() shadow_rect.bottomleft = (self.battle_mech.col * Board.TILE_SIZE), \ (self.battle_mech.row * Board.TILE_SIZE) shadow.position = shadow_rect.center self.shadow = shadow rect = img_static.get_rect() rect.bottomleft = (self.battle_mech.col * Board.TILE_SIZE) - (img_static.width//2 - shadow.width//2), \ (self.battle_mech.row * Board.TILE_SIZE) self.position = rect.center self.node = BatchNode() self.add(self.node, z=2) img_static.y = Board.TILE_SIZE//4 self.node.add(img_static) self.img_static = img_static img_ct = Sprite(mech_img_grid[1]) img_ct.y = Board.TILE_SIZE//4 self.img_ct = img_ct img_ll = Sprite(mech_img_grid[4]) img_ll.y = Board.TILE_SIZE//4 self.img_ll = img_ll img_rl = Sprite(mech_img_grid[5]) img_rl.y = Board.TILE_SIZE//4 self.img_rl = img_rl img_la = Sprite(mech_img_grid[2]) img_la.y = Board.TILE_SIZE//4 self.img_la = img_la img_ra = Sprite(mech_img_grid[3]) img_ra.y = Board.TILE_SIZE//4 self.img_ra = img_ra # testing the stats stuff self.stats = BatchNode() self.updateStatsIndicators()
class TestLayer(cocos.layer.Layer): is_event_handler = True def __init__(self): super( TestLayer, self ).__init__() self.mouse_x = self.mouse_y = 0 x,y = director.get_window_size() self.sprite1 = Sprite('grossini.png', anchor=(0, 0)) self.sprite_rect = None self.add(self.sprite1, z=2) self.sprite1.position = x // 3, y // 2 self.show_rect() self.do( Delay(2) + CallFunc(self.mov) + Delay(2) + CallFunc(self.zoom) + Delay(2) + CallFunc(self.scalex) + Delay(2) + CallFunc(self.rot) ) self.mouse_mark = cocos.layer.ColorLayer(0, 0, 255, 255, 20, 20) self.add(self.mouse_mark, z=3) def show_rect(self): if self.sprite_rect: self.remove(self.sprite_rect) rect = self.sprite1.get_rect() self.sprite_rect = ColorLayer(255, 255, 255, 255, width=rect.width, height=rect.height) self.sprite_rect.position = rect.position self.add(self.sprite_rect, z=1) def mov(self): x,y = director.get_window_size() self.sprite1.position = (x * 2 // 3, y//2) self.show_rect() def rot(self): self.sprite1.rotation = 90 self.show_rect() def zoom(self): self.sprite1.scale = 2 self.show_rect() def scalex(self): self.sprite1.scale_x = 0.5 self.show_rect() def on_mouse_press(self, x, y, buttons, modifiers): self.update_mouse_mark(x, y) def on_mouse_drag( self, x, y, dx, dy, buttons, modifiers ): self.update_mouse_mark(x, y) def update_mouse_mark(self, x, y): x, y = director.get_virtual_coordinates (x, y) self.mouse_mark.position = (x-5, y-5) rect = self.sprite1.get_rect() # mouse hit ? if rect.contains(x, y): self.mouse_mark.color = (255, 0, 0) else: self.mouse_mark.color = (0, 0, 255)
class HudLayer(Layer, pyglet.event.EventDispatcher): is_event_handler = True def __init__(self, state): super(HudLayer, self).__init__() self.state = state self.resourceLabel = Label("RESOURCES %d/2000" % self.state.player1.resources, font_name="DejaVu Sans", font_size=32, anchor_x='center', anchor_y='center') self.resourceLabel.position = 1280 / 2, 720 - 20 self.add(self.resourceLabel) left = 1280 / 2 - 128 / 2 - 20 - 128 / 2 self.tankButton = Sprite(Constants.Paths.Buttons.tank) self.tankButton.position = left, 80 self.add(self.tankButton) left += self.tankButton.width + 20 self.missileButton = Sprite(Constants.Paths.Buttons.missile) self.missileButton.position = left, 80 self.add(self.missileButton) left += self.missileButton.width + 20 self.nukeButton = Sprite(Constants.Paths.Buttons.nuke) self.nukeButton.position = left, 80 self.add(self.nukeButton) self.schedule_interval(self.constitutiveCitizenReward, 0.2) def constitutiveCitizenReward(self, dt): self.state.player1.resources += 10 self.state.player2.resources += 10 if (self.state.player1.resources > 2000): self.state.player1.resources = 2000 if (self.state.player2.resources > 2000): self.state.player2.resources = 2000 self.setResourceLabel(self.state.player1.resources) def setResourceLabel(self, resources): self.resourceLabel.element.text = "RESOURCES %d/2000" % self.state.player1.resources def on_mouse_motion(self, x, y, dx, dy): if self.tankButton.get_rect().contains(x, y): self.tankButton.scale = 1.1 else: self.tankButton.scale = 1.0 if self.missileButton.get_rect().contains(x, y): self.missileButton.scale = 1.1 else: self.missileButton.scale = 1.0 if self.nukeButton.get_rect().contains(x, y): self.nukeButton.scale = 1.1 else: self.nukeButton.scale = 1.0 def on_mouse_press(self, x, y, buttons, modifiers): if self.tankButton.get_rect().contains(x, y): if self.state.player1.resources >= 200: self.state.player1.resources -= 200 self.setResourceLabel(self.state.player1.resources) self.dispatch_event('on_tank_purchase', self)
def __init__(self): super(Board, self).__init__() Board.BOARD = self self.boardMap = {} self.cellMap = {} # add basic ground ground_img = Resources.ground_img node = BatchNode() self.add(node, z=0) for row in range(self.numRows): for col in range(self.numCols): cell = Cell(ground_img) rect = cell.get_rect() rect.bottomleft = col * 32, row * 32 cell.position = rect.center node.add(cell, z=0) self.cellMap[(col, row)] = cell # add buildings buildings_tex = Resources.buildings_tex # test 3x2 Building at 1,4 self.boardMap[(1, 4)] = {self.KEY_TYPE: self.TYPE_BUILDING, self.KEY_COLUMNS: 3, self.KEY_ROWS: 2, self.KEY_LEVEL: 1, self.KEY_ELEVATION: 0, self.KEY_IMAGES: buildings_tex[(0, 0):(3, 3)]} self.boardMap[(2, 4)] = {self.KEY_REF: (1, 4)} self.boardMap[(3, 4)] = {self.KEY_REF: (1, 4)} self.boardMap[(1, 5)] = {self.KEY_REF: (1, 4)} self.boardMap[(2, 5)] = {self.KEY_REF: (1, 4)} self.boardMap[(3, 5)] = {self.KEY_REF: (1, 4)} # test 2x2 Building at 5,4 self.boardMap[(5, 4)] = {self.KEY_TYPE: self.TYPE_BUILDING, self.KEY_COLUMNS: 2, self.KEY_ROWS: 2, self.KEY_LEVEL: 1, self.KEY_ELEVATION: 0, self.KEY_IMAGES: buildings_tex[(3, 0):(7, 2)]} self.boardMap[(6, 4)] = {self.KEY_REF: (5, 4)} self.boardMap[(5, 5)] = {self.KEY_REF: (5, 4)} self.boardMap[(6, 5)] = {self.KEY_REF: (5, 4)} # test 2x2 Building at 10,6 self.boardMap[(10, 6)] = {self.KEY_TYPE: self.TYPE_BUILDING, self.KEY_COLUMNS: 2, self.KEY_ROWS: 2, self.KEY_LEVEL: 1, self.KEY_ELEVATION: 0, self.KEY_IMAGES: buildings_tex[(3, 2):(7, 4)]} self.boardMap[(11, 6)] = {self.KEY_REF: (10, 6)} self.boardMap[(10, 7)] = {self.KEY_REF: (10, 6)} self.boardMap[(11, 7)] = {self.KEY_REF: (10, 6)} # test 3x2 Building at 10,2 self.boardMap[(10, 2)] = {self.KEY_TYPE: self.TYPE_BUILDING, self.KEY_COLUMNS: 3, self.KEY_ROWS: 2, self.KEY_LEVEL: 1, self.KEY_ELEVATION: 0, self.KEY_IMAGES: buildings_tex[(3, 5):(7, 8)]} self.boardMap[(11, 2)] = {self.KEY_REF: (10, 2)} self.boardMap[(12, 2)] = {self.KEY_REF: (10, 2)} self.boardMap[(10, 3)] = {self.KEY_REF: (10, 2)} self.boardMap[(11, 3)] = {self.KEY_REF: (10, 2)} self.boardMap[(12, 3)] = {self.KEY_REF: (10, 2)} # test 2x2x2 Building at 12,12 self.boardMap[(12, 12)] = {self.KEY_TYPE: self.TYPE_BUILDING, self.KEY_COLUMNS: 2, self.KEY_ROWS: 2, self.KEY_LEVEL: 2, self.KEY_ELEVATION: 0, self.KEY_IMAGES: buildings_tex[(3, 10):(8, 12)]} self.boardMap[(13, 12)] = {self.KEY_REF: (12, 12)} self.boardMap[(12, 13)] = {self.KEY_REF: (12, 12)} self.boardMap[(13, 13)] = {self.KEY_REF: (12, 12)} # test 3x3 Building at 15,10 self.boardMap[(15, 10)] = {self.KEY_TYPE: self.TYPE_BUILDING, self.KEY_COLUMNS: 3, self.KEY_ROWS: 3, self.KEY_LEVEL: 1, self.KEY_ELEVATION: 0, self.KEY_IMAGES: buildings_tex[(7, 10):(13, 13)]} self.boardMap[(16, 10)] = {self.KEY_REF: (15, 10)} self.boardMap[(17, 10)] = {self.KEY_REF: (15, 10)} self.boardMap[(15, 11)] = {self.KEY_REF: (15, 10)} self.boardMap[(16, 11)] = {self.KEY_REF: (15, 10)} self.boardMap[(17, 11)] = {self.KEY_REF: (15, 10)} self.boardMap[(15, 12)] = {self.KEY_REF: (15, 10)} self.boardMap[(16, 12)] = {self.KEY_REF: (15, 10)} self.boardMap[(17, 12)] = {self.KEY_REF: (15, 10)} # test 5x2 Building at 3,14 self.boardMap[(3, 14)] = {self.KEY_TYPE: self.TYPE_BUILDING, self.KEY_COLUMNS: 5, self.KEY_ROWS: 2, self.KEY_LEVEL: 0, self.KEY_ELEVATION: 0, self.KEY_IMAGES: buildings_tex[(9, 0):(11, 5)]} self.boardMap[(4, 14)] = {self.KEY_REF: (3, 14)} self.boardMap[(5, 14)] = {self.KEY_REF: (3, 14)} self.boardMap[(6, 14)] = {self.KEY_REF: (3, 14)} self.boardMap[(7, 14)] = {self.KEY_REF: (3, 14)} self.boardMap[(3, 15)] = {self.KEY_REF: (3, 14)} self.boardMap[(4, 15)] = {self.KEY_REF: (3, 14)} self.boardMap[(5, 15)] = {self.KEY_REF: (3, 14)} self.boardMap[(6, 15)] = {self.KEY_REF: (3, 14)} self.boardMap[(7, 15)] = {self.KEY_REF: (3, 14)} for col, row in self.boardMap: loc = (col, row) cell_data = self.boardMap[loc] cell_images = cell_data.get(self.KEY_IMAGES) if cell_images is not None: cell_level = cell_data[self.KEY_LEVEL] cell_z = (self.numCols - row - cell_level) * 10 cell_batch = BatchNode() cell_batch.position = col * self.TILE_SIZE, row * self.TILE_SIZE self.add(cell_batch, z=cell_z) cell_cols = cell_data[self.KEY_COLUMNS] cell_rows = cell_data[self.KEY_ROWS] for this_row in range(cell_rows + cell_level): for this_col in range(cell_cols): cell_index = this_col + (this_row * cell_cols) cell_sprite = Sprite(cell_images[cell_index]) cell_rect = cell_sprite.get_rect() cell_rect.bottomleft = this_col * self.TILE_SIZE, this_row * self.TILE_SIZE cell_sprite.position = cell_rect.center cell_batch.add(cell_sprite)
class Game(cocos.layer.ScrollableLayer): is_event_handler = True def __init__(self, name): super(Game, self).__init__() self.name = name self.keys_pressed = set() self.projectiles = list() self.background = Sprite( image=get_background_path() ) # à cacher global BACKGROUND_RECT BACKGROUND_RECT = self.background.get_rect() offset = BACKGROUND_RECT.width/2, BACKGROUND_RECT.height/2 load_wall_array() global SPAWN self.cursor = Cursor(SPAWN) ## self.background.position = offset spawn_delayed([self], [self.cursor]) self.add(self.background) self.adstop = AdStop(self.cursor) self.add(self.adstop) self.bullettime = BulletTime(self.cursor) self.add(self.bullettime) self.add(self.cursor) # adding stuff to the collision world global COL_MGR COL_MGR = cocos.collision_model.CollisionManagerGrid( BACKGROUND_RECT.x + BACKGROUND_RECT.width/2, BACKGROUND_RECT.x + 3*BACKGROUND_RECT.width/2, BACKGROUND_RECT.y + BACKGROUND_RECT.height/2, BACKGROUND_RECT.y + 3*BACKGROUND_RECT.height / 2, 16, 16 ) # self.debug() self.schedule(self.update) # used to draw collisions boxes etc def debug(self): global CURRENT_WALL_ARRAY for rect in CURRENT_WALL_ARRAY: draw_rect(rect.rect, self) draw_rect(self.cursor.get_rect(), self) # holds logic def update(self, delta): if self.cursor.bullettime: delta *= 0.5 # reacting to keypresses for k in self.keys_pressed: if k == key.LEFT: self.cursor.do(RotateBy(-self.cursor.angular_speed * delta, 0)) if k == key.RIGHT: self.cursor.do(RotateBy(self.cursor.angular_speed * delta, 0)) if k == key.SPACE: self.adstop.activate() if k == key.B: self.bullettime.activate() self.cursor.update(delta) self.adstop.act(delta) self.bullettime.act(delta) global COL_MGR global CURRENT_WALL_ARRAY global DELAYED_ARRAY COL_MGR.clear() # fast, no leaks even if changed cshapes COL_MGR.add(self.cursor) # it's the way internet says it has to be done for delayed in DELAYED_ARRAY: delayed.update(delta) if type(delayed) == Turret: for proj in delayed.projectiles: COL_MGR.add(proj) for wall in CURRENT_WALL_ARRAY: COL_MGR.add(wall) for p in self.projectiles: p.update(delta) COL_MGR.add(p) for other in COL_MGR.iter_colliding(p): if type(other) == InvisibleWall: self.remove(p) self.projectiles.remove(p) for other in COL_MGR.iter_colliding(self.cursor): if type(other) == Projectile: if self.cursor.shielded: self.adstop.reset() other.remove() continue else: print("you lost") run_level(self.name) break split = other.name.split(":") if split[0] == "win": print("you win") if split[1] == "end": print("Java c'est plus meilleur.") sys.exit(0) else: run_level(split[1]) break elif split[0] == "lose": print("you lost") run_level(self.name) break global THE_ELDER_SCROLLS_MANAGER THE_ELDER_SCROLLS_MANAGER.set_focus(self.cursor.position[0], self.cursor.position[1]) def on_key_press(self, key, modifiers): self.keys_pressed.add(key) def on_key_release(self, key, modifiers): try: self.keys_pressed.remove(key) except: print('tried to remove a key during level change !')
def updatePlayerUnitStats(self, battle_unit): if self.unit_display is not None: self.unit_display.kill() self.unit_name.kill() self.unit_variant.kill() self.unit_stats.kill() self.unit_values.kill() if battle_unit is None: # Hide player unit stats at bottom left self.unit_display = None self.unit_name = None self.unit_variant = None self.unit_stats = None self.unit_values = None return size = director.get_window_size() width = size[0] height = size[1] 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() # testing with masking only a portion of the image damage_height = int( mech_img_static.height) # int(mech_img_static.height * 0.67) 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 img2 = Image.new('RGBA', mask.size, color=(225, 225, 225, 200)) 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 = Board.TILE_SIZE // 2 + mech_sprite.width // 2, \ Board.TILE_SIZE + mech_sprite.height // 2 self.unit_display.add(mech_sprite) self.add(self.unit_display) # Show unit name above the image self.unit_name = floaters.TextFloater(battle_unit.getName(), font_name='TranscendsGames', font_size=Board.TILE_SIZE // 2, anchor_x='left', anchor_y='bottom') self.unit_name.position = Board.TILE_SIZE // 2, mech_sprite.get_rect( ).topleft[1] self.add(self.unit_name) # Show unit variant below the image self.unit_variant = floaters.TextFloater( battle_unit.getVariant().upper(), font_name='TranscendsGames', font_size=Board.TILE_SIZE // 3, anchor_x='left', anchor_y='top') self.unit_variant.position = Board.TILE_SIZE // 2, Board.TILE_SIZE - 4 self.add(self.unit_variant) # Show armor, structure, heat stats next to the image (top) self.unit_stats = UnitStats(battle_unit) stats_pos = mech_sprite.get_rect().topright self.unit_stats.position = 4 + stats_pos[0], stats_pos[ 1] - self.unit_stats.height self.add(self.unit_stats) # 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)
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)