def draw( self ): super(cocos_box2d_layer,self).draw() glLoadIdentity() bodies = self.world.GetBodyList() i = 0 for b in bodies: userdata = b.GetUserData() if not userdata: userdata = {} b.SetUserData(userdata) sprite = userdata.get("sprite") if not sprite: if userdata.get("sister1"): sprite = Sprite(self.image_sister1) elif userdata.get("sister2"): sprite = Sprite(self.image_sister2) else: sprite = Sprite(self.image) self.add(sprite) userdata["sprite"] = sprite sprite.position = (b.position.x * self.zoom), (b.position.y * self.zoom) degrees = (b.GetAngle() * 180) / math.pi sprite.rotation = degrees # center the image glTranslatef(-320, -240, -320.0)
def __init__(self): super(TitleLayer, self).__init__() w, h = director.get_window_size() logo = Sprite('Moon_1.jpg') lh = logo.height logo.position = (w//2, h//2) self.add(logo)
def _add_indicator(self, indicator_name, indicator_img): indicator = Sprite(indicator_img) indicator.position = self.position self.add(indicator, z=len(self.indicators)) self.indicators[indicator_name] = indicator
def draw( self ): super(GameCtrl, self).draw() glLoadIdentity() bodies = self.model.world.GetBodyList() i = 0 for b in bodies: props = b.GetUserData() if not props: continue sprite = props.get_sprite() if not sprite: if props.isCharacter: sprite = Sprite(self.image) elif props.isBlock: shape = b.GetShapeList()[0] vertices = shape.getVertices_b2Vec2() sprite = RectBlock(vertices) print sprite.p1, sprite.p2, sprite.p3, sprite.p4 else: continue props.set_sprite(sprite) self.add(sprite) sprite.position = (b.position.x * self.model.zoom), \ (b.position.y * self.model.zoom) degrees = -(b.GetAngle() * 180) / math.pi sprite.rotation = degrees # center the image glTranslatef(-320, -240, -320.0)
def __init__(self): super(GameScene, self).__init__() self.dimension = 616 self.position = 76, 348 track_sprite = Sprite('images/track.png') track_sprite.position = self.dimension/2, 27 self.add( track_sprite, z=1 ) # paddle self.paddle = Paddle(self.dimension, self.dimension, 27) self.add( self.paddle.sprite, z=2) # ball and movement self.ball_movement = BounceBoundedMove(self.dimension, self.dimension, 10) self.ball = CollidableRectSprite("images/ball.png", self.dimension/2, self.dimension/2) self.add(self.ball, z=10) self.ball.velocity = (200, 136) self.ball.do(self.ball_movement) self.do(GameClock(10000)) self.collision = cm.CollisionManagerBruteForce(); self.collision.add(self.paddle.sprite) self.collision.add(self.ball)
def __init__(self): super( TestLayer, self ).__init__() x,y = director.get_window_size() self.batch = cocos.sprite.BatchNode() self.add( self.batch ) self.sprite = Sprite('grossini.png') self.sprite.position = x/2, y/2 self.sprite2 = Sprite('grossini.png') self.sprite2.position = 20, 30 self.sprite5 = Sprite('grossini.png') self.sprite5.position = -20, 30 self.sprite3 = Sprite('grossini.png') self.sprite3.position = -20, -30 self.sprite4 = Sprite('grossini.png') self.sprite4.position = 20, -30 self.sprite.add( self.sprite2, z=-1, name="temp" ) self.sprite3.add( self.sprite4, z=1 ) self.batch.add( self.sprite ) self.sprite.add( self.sprite3, z=-1 ) self.sprite2.add( self.sprite5, z=1 ) self.sprite.remove("temp")
def __init__(self, color="blue", vision=False): super().__init__() # create and add Sprites for ghost self.ghost1 = Sprite("images/" + color + "1.png") self.ghost2 = Sprite("images/" + color + "2.png") self.eyes = Sprite("images/eyesDown.png") self.sprites.append(self.ghost1) self.sprites.append(self.ghost2) self.sprites.append(self.eyes) self.charRect = Rect(40, 40, self.ghost1.width * 0.12, self.ghost1.height * 0.12) self.charRect.center = (40, 40); for ghost in self.sprites: self.add(ghost) ghost.position = self.charRect.center ghost.scale = 0.12 # if this is my player add a vision field if vision: visionSprite = Sprite("images/vision.png") self.sprites.append(visionSprite) self.add(visionSprite) visionSprite.position = self.charRect.center # Animate ghost self.ghost1.do(Repeat(Blink(1, 0.3)))
def __init__(self, game, pos, bonus_type=0): self._game = game self.is_alive = True self._life = constants.ENEMY_ARMOR self.bonus_type = bonus_type # Mouse pointer 'body' self.aim = pymunk.Body(1, 1) self.aim_shape = pymunk.Circle(self.aim, 1, (0, 0)) self.aim_shape.layers = 0b000 # The 'aim' should not collide with any objects self.aim.position = pos # Enemy body mass = 3 radius = 15 inertia = pymunk.moment_for_circle(mass, 0, radius, (0, 0)) self.body = pymunk.Body(mass, inertia) shape = pymunk.Circle(self.body, radius, (0, 0)) shape.elasticity = 0.9 shape.friction = 0.8 shape.collision_type = 3 self.shape = shape if not bonus_type: self.sprite = Sprite("enemy.png") elif bonus_type == constants.HEALTH_BONUS_TYPE: animation = pyglet.resource.animation("bonus_enemy_green.gif") self.sprite = Sprite(animation) elif bonus_type == constants.KILLALL_BONUS_TYPE: animation = pyglet.resource.animation("bonus_enemy_yellow.gif") self.sprite = Sprite(animation) self.sprite.do(Repeat(RotateBy(360, 2))) self.body.position = self.sprite.position = pos self.body.apply_force(-(self.body.mass + self.aim.mass) * game.space.gravity) # Connect aim and body with a DampedSpring - this should create the effect of flying through the air to the # player self.move = pymunk.constraint.DampedSpring(self.aim, self.body, (0, 0), (0, 0), 1, 600.0, 100) game.space.add(self.body, self.shape, self.aim, self.move)
def __init__(self, sock): super(Room, self).__init__() self.sock = sock self.image1 = pyglet.resource.image('qiuqiu.jpg') self.image1.anchor_x = self.image1.width/2 self.image1.anchor_y = self.image1.height/2 sprite1 = Sprite(self.image1) self.add(sprite1, z=0, name="qiuqiu") sprite1.position = 220, 240 self.image2 = pyglet.resource.image('heishen.jpg') self.image2.anchor_x = self.image2.width/2 self.image2.anchor_y = self.image2.height/2 sprite2 = Sprite(self.image2) self.add(sprite2, z=0, name="heishen") sprite2.position = 420, 240 label = cocos.text.Label('Pick one? Click He or She!', font_name='liberationmono', font_size=16, anchor_x='center', anchor_y='center') label.position = 320, 80 self.add( label )
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 on_enter( self ): super(SpriteMoveTo,self).on_enter() sprite3 = Sprite( self.image ) self.add(sprite3) sprite3.position = 320,300 sprite3.do( MoveTo( (620,300), 4 ) )
def parse_json_file( self, jsonfile ): '''data parser''' layers_list= simplejson.load(open( jsonfile ))['layers'] for layer in layers_list: type = layer['layer_type'] if type == 'sprite': z = layer.get('z',0) sprites = layer.get('data',[]) batch = BatchNode() for sprite in sprites['sprites']: rect = sprite['rect'] region = pyglet.image.TextureRegion( rect[0], rect[1], 0, rect[2], rect[3], self.atlas.texture ) s = Sprite( region, sprite['position'], sprite['rotation'], sprite['scale'], sprite['opacity']) if "label" in sprite: s.label = sprite['label'] batch.add( s ) self.add( batch, z=z )
class ImageMenuItem (BaseMenuItem): """ A menu item that shows a selectable Image """ def __init__(self, image, callback_func, *args, **kwargs): if isinstance(image, string_types): image = pyglet.resource.image(image) self.image = image super(ImageMenuItem, self).__init__(callback_func, *args, **kwargs) def generateWidgets(self, pos_x, pos_y, font_item, font_item_selected): anchors = {'left': 0, 'center': 0.5, 'right': 1, 'top': 1, 'bottom': 0} anchor = (anchors[font_item['anchor_x']] * self.image.width, anchors[font_item['anchor_y']] * self.image.height) self.item = Sprite(self.image, anchor=anchor, opacity=255, color=font_item['color'][:3]) self.item.scale = font_item['font_size'] / float(self.item.height) self.item.position = int(pos_x), int(pos_y) self.selected_item = Sprite(self.image, anchor=anchor, color=font_item_selected['color'][:3]) self.selected_item.scale = (font_item_selected['font_size'] / float(self.selected_item.height)) self.selected_item.position = int(pos_x), int(pos_y) def draw(self): glPushMatrix() self.transform() if self.is_selected: self.selected_item.draw() else: self.item.draw() glPopMatrix()
class BuildingMenu(Layer): def __init__(self): super(BuildingMenu, self).__init__() self.end_of_init() def end_of_init(self): w, h = director.get_window_size() sc = 1920//w self.visible = 0 self.b_types = {} self.b_types[0] = SecondB_menu('trap', 0) self.b_types[1] = SecondB_menu('monster', 1) self.b_types[2] = SecondB_menu('magic', 2) self.b_types[3] = SecondB_menu('wall', 3) self.scroll = Sprite(Images.menu_scroll, (1500//sc, 380//sc), scale = 1/sc) self.active = -1 def draw(self): if self.visible: w, h = director.get_window_size() sc = 1920//w self.scroll.draw() for b_type in self.b_types: self.b_types[b_type].sprite.draw() if self.active == b_type: self.b_types[b_type].draw()
def gamestart(self): self.update_hud() self.paddle.reset() self.ball.reset() # 添加砖块并且显示出来 # 先删除残存的砖块 for b in self.blocks: self.remove(b) # 再初始化新的砖块 self.blocks = [] self.level += 1 self.hud2.element.text = 'Level:' + str(self.level) if self.level > 4: self.level = 1 levelfile = 'level' + str(self.level) + '.txt' positions = level_from_file(levelfile) number_of_blocks = len(positions) for i in range(number_of_blocks): b = Sprite('images/zhuan.png', anchor=(0, 0)) b.position = positions[i] # b.color = (randint(0, 255), randint(0, 255), randint(0, 255)) # b.position = (randint(0, 500), 400) self.add(b) self.blocks.append(b)
def __init__(self, client, points=9, eye=1, wait=1, randomize=1, auto=0, speed=1, level=3): super(CalibrationLayer, self).__init__(0, 0, 255, 255) self.client = client self.points = points self.eye = eye self.wait = wait self.randomize = randomize self.auto = auto self.speed = speed self.level = level self.on_success = None self.on_failure = None self.window = director.window.get_size() self.screen = director.get_window_size() self.center_x = self.screen[0] / 2 self.center_y = self.screen[1] / 2 self.win_scale = (self.screen[0] / self.window[0], self.screen[1] / self.window[1]) self.font = font.load("Cut Outs for 3D FX", 32) self.circle_img = self.font.get_glyphs("E")[0].get_texture(True) self.circle_img.anchor_x = "center" self.circle_img.anchor_y = "center" self.pnt_img = self.font.get_glyphs("Y")[0].get_texture(True) self.pnt_img.anchor_x = "center" self.pnt_img.anchor_y = "center" self.circle = Sprite(self.circle_img, color=(255, 255, 0), scale=1, opacity=0) self.spinner = Sprite( resource.image("spinner.png"), position=(self.screen[0] / 2, self.screen[1] / 2), color=(255, 255, 255) )
def init_node_sprites(self, wipe=False): if wipe: #wipe old sprites #for n in self.G.nodes_iter(): # self.map.node[n]['sprite'] = None self.remove("nodes") #make node sprites nodes = BatchNode() raw_positions = self.map.get_positions() rotate_effect = Repeat(RotateBy(-360, 2)) for n in raw_positions: #get node position x, y = raw_positions[n] pos = (x * settings.LVL_W, y * settings.LVL_H) #get type of node type = self.map.get_type(n) #make sprite node_spr = Sprite( image=settings.IMAGE_DATA[type], position=pos, ) type != "factory" or node_spr.do(rotate_effect) self.nodesprites[n] = node_spr nodes.add(node_spr) #add nodes to map_layer self.add(nodes, z=1, name="nodes") self.update_node_sprites()
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 __init__(self): super( TestLayer, self ).__init__(0,0,50,255) # get the sizes sprite = Sprite('fire.png') w, h = sprite.width/2, sprite.height/2 # thes are the center of the sprites, where to click self.positions = [ (w, h), (sw-w, h), (w, sh-h), (sw-w, sh-h), (sw//2, sh//2), ] # let's draw the sprites self.sprites = [] for pos in self.positions: sprite = Sprite('fire.png') sprite.position = pos self.add(sprite) self.sprites.append(sprite) self.dd = sprite
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
class Tile(): def __init__(self, image, posx, posy ,map_posx, map_posy): w, h = director.get_window_size() sc = 1920/w self.namenumber = 0 self.name = 'floor' self.map_pos_x = map_posx self.map_pos_y = map_posy self.open_P = 0 self.sprite = Sprite(Images.tile_image[self.name], (posx, posy), scale = 1/sc) self.sprite_smoke = Sprite(Images.tile_image['smoke'], (posx, posy), scale = 1/sc) self.monster = 0 self.smoke = 0 self.buildav = 1 self.wall = 0 def next_turn(self): if self.smoke: self.smoke = self.smoke - 1 def next_turn_DM(self): self.buildav = 1 if (self.open_P) or (self.smoke): self.buildav = 0 def on_click_P(self): self.open_P = 1 def draw(self): self.sprite.image = Images.tile_image[self.name] self.sprite.draw() if self.smoke: self.sprite_smoke.draw()
class SpriteLayer(ScrollableLayer): def __init__(self): super(SpriteLayer, self).__init__() # And, just like last time, we make our sprite and have it do the action we define self.sprite = Sprite("assets/img/grossini.png") self.add(self.sprite) self.sprite.do(GameAction())
def draw(self): w, h = director.get_window_size() sc = 1920/w if (self.hero.turnav > 0): c = Sprite(Images.hero_icons[self.hero.name], ((1235 + Icon_size*self.number*1.1)//sc, 960//sc), scale = 1/sc) else: c = Sprite(Images.hero_icons_black[self.hero.name], ((1235 + Icon_size*self.number*1.1)//sc, 960//sc), scale = 1/sc) c.draw()
def __init__(self): super(GameDecoratorLayer,self).__init__() bg = "bgs/the_void.png" sprite = Sprite(bg) sprite.x = sprite.width/2 sprite.y = sprite.height/2 self.add(sprite)
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 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 on_enter( self ): super(SpriteBezier,self).on_enter() sprite = Sprite( self.image ) self.add( sprite ) self.position = 120,100 sprite.do( Bezier( foo.curva, 5 ) )
def on_enter( self ): super(SpriteJump,self).on_enter() sprite = Sprite( self.image ) self.add( sprite ) self.position = 120,100 sprite.do( JumpBy( (400,0), height=100, jumps=4, duration=3 ) )
def on_enter( self ): super(SpriteRotate,self).on_enter() sprite = Sprite( self.image ) self.add( sprite ) self.position = 320,200 sprite.do( RotateBy( 360, 2 ) )
def on_enter( self ): super(SpriteScale,self).on_enter() sprite = Sprite( self.image ) self.add( sprite ) sprite.position = 320,200 sprite.do( ScaleTo( 10, 5 ) )
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
class TestLayer(cocos.layer.Layer): def __init__(self): super(TestLayer, self).__init__() x, y = director.get_window_size() self.sprite1 = Sprite('grossini.png', (x // 4, y // 2)) self.add(self.sprite1) self.sprite2 = Sprite('grossini.png', ((x // 4) * 3, y // 2)) self.add(self.sprite2) self.sprite1.do(Accelerate(Speed(Rotate(360, 1), 0.1), 4)) self.sprite2.do(Speed(Accelerate(Rotate(360, 1), 4), 0.1))
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.do(Show()) self.sprite.do(Delay(1) + CallFuncS(make_visible))
def __init__(self, scale=1): """initializer""" gallery = Gallery() sprite_antshovel_stop = Sprite(gallery["button"]["antshovel_stop"]) sprite_antshovel_slow = Sprite(gallery["button"]["antshovel_slow"]) sprite_antshovel_fast = Sprite(gallery["button"]["antshovel_fast"]) antshovel_stop = ButtonState(sprite=sprite_antshovel_stop, event=events.emit_do_antshovel) antshovel_slow = ButtonState(sprite=sprite_antshovel_slow, event=events.emit_do_antshovel) antshovel_fast = ButtonState(sprite=sprite_antshovel_fast, event=events.emit_do_antshovel) states = [antshovel_stop, antshovel_slow, antshovel_fast] scale=scale MultiStateButton.__init__(self, states=states, scale=scale, down_scale=1) self.position = self.width / 2, self.height / 2
class TestLayer(cocos.layer.Layer): def __init__(self): super(TestLayer, self).__init__() x, y = director.get_window_size() self.sprite = Sprite('grossini.png', (x // 5, y // 3 * 2)) self.add(self.sprite) self.sprite.do(JumpTo((x // 5 * 4, 100), 100, 10, 6)) self.sprite2 = Sprite('grossini.png', (x // 5, y // 3)) self.add(self.sprite2) self.sprite2.do(JumpBy((x // 5 * 4, 100), 100, 10, 6))
def on_enter( self ): super(SpriteReuseAction,self).on_enter() sprite1 = Sprite( self.image_sister1) sprite2 = Sprite( self.image_sister2) self.add( sprite1 ) self.add( sprite2 ) sprite1.position = 120,250 sprite2.position = 20,100 jump = JumpBy( (400,0), 150, 4, 4 ) sprite1.do( jump ) sprite2.do( jump )
def generateWidgets(self, pos_x, pos_y, font_item, font_item_selected): anchors = {'left': 0, 'center': 0.5, 'right': 1, 'top': 1, 'bottom': 0} anchor = (anchors[font_item['anchor_x']] * self.image.width, anchors[font_item['anchor_y']] * self.image.height) self.item = Sprite(self.image, anchor=anchor, opacity=255, color=font_item['color'][:3]) self.item.scale = font_item['font_size'] / float(self.item.height) self.item.position = int(pos_x), int(pos_y) self.selected_item = Sprite(self.image, anchor=anchor, color=font_item_selected['color'][:3]) self.selected_item.scale = (font_item_selected['font_size'] / float(self.selected_item.height)) self.selected_item.position = int(pos_x), int(pos_y)
class TestLayer(cocos.layer.Layer): def __init__(self): super(TestLayer, self).__init__() x, y = director.get_window_size() self.sprite1 = Sprite('grossini.png', (0, y // 3)) self.add(self.sprite1) self.sprite1.do(MoveBy((x / 10, 0), 1) * 5) self.sprite2 = Sprite('grossini.png', (0, y * 2 // 3)) self.add(self.sprite2) self.sprite2.do(loop(MoveBy((x / 10, 0), 1), 5))
def __init__(self, position: Vector2, block_color, scale=1, b_type=""): self.block_color = block_color self.b_type = b_type image = get_img_by_color(block_color) Sprite.__init__(self, image=image, position=position, scale=scale) if (not b_type == ''): #retangulo para calculo de colisao, como coodenadas realtivas a layer do jogo principal pos = game_controller.game_controller.main_game.point_to_local( (self.x, self.y)) self.cshape = collision_model.AARectShape(pos, self.width / 2, self.height / 2)
class TestLayer(cocos.layer.Layer): def __init__(self): super(TestLayer, self).__init__() x, y = director.get_window_size() self.sprite = Sprite('grossini.png', (x // 2, y // 2)) self.add(self.sprite) self.sprite.do(FadeTo(0, 5)) self.sprite2 = Sprite('grossini.png', (x // 4 * 3, y // 2), opacity=0) self.add(self.sprite2) self.sprite2.do(FadeTo(255, 5))
def __init__(self): super(TestLayer, self).__init__() x, y = director.get_window_size() self.sprite = Sprite('grossini.png', (x / 2, y / 2)) self.add(self.sprite) self.sprite2 = Sprite('grossini.png', (x / 2, y / 2)) self.add(self.sprite2) seq = MoveBy((x / 2, 0)) + MoveBy((0, y / 2)) self.sprite.do(seq) self.sprite2.do(Reverse(seq))
def __init__(self): # add background layer super(GameLayer, self).__init__() size = director.get_window_size() backgroundSprite = Sprite('resources\\background.jpg') backgroundSprite.position = (size[0] / 2, size[1] / 2) sc = ScaleBy(2, 0) backgroundSprite.do(sc) self.add(backgroundSprite) # add snake sprite self.snake = Snake() self.add(self.snake)
def __init__(self): super(TestLayer, self).__init__() x, y = director.get_window_size() self.sprite = Sprite('grossini.png', (x // 4, y // 2)) self.add(self.sprite) self.sprite.do(Delay(1) + ToggleVisibility()) self.sprite2 = Sprite('grossini.png', (x // 4 * 3, y // 2)) self.sprite2.visible = False self.add(self.sprite2) self.sprite2.do(Delay(1) + ToggleVisibility())
def __init__(self, size=80): super().__init__() self.blood_right = Sprite('sprite/Blood_r.png', anchor=(0, size / 2)) self.blood_left = Sprite('sprite/Blood_l.png', anchor=(size / 2, size / 2)) self.left = Sprite('sprite/Left.png', anchor=(size / 2, size / 2)) self.right = Sprite('sprite/Right.png', anchor=(0, size / 2)) self.add(self.blood_right) self.add(self.left) self.add(self.blood_left) self.add(self.right) self.right.visible = False
class _PlayerAnimation(Layer): def __init__(self, R): super(_PlayerAnimation, self).__init__() self.R = R self.SamplePlayer = Sprite(self.R.PLAYERANIME[0]) self.SamplePlayer.scale = 0.5 self.size = director.get_window_size() #SIMPLE ANIMATION _WH = self.SamplePlayer.get_AABB() _place = (-_WH.width, self.size[1] - 120) _move = MoveBy((self.size[0] + (_WH.width * 2), 0), 3) self.SamplePlayer.do(Repeat(Place(_place) + _move)) self.add(self.SamplePlayer)
class SpriteLayer(ScrollableLayer): is_event_handler = True def __init__(self): super(SpriteLayer, self).__init__() image = pyglet.image.load("resources/sprite.png") self.collision_manager = cm.CollisionManagerBruteForce() self.direction = "right" self.bullets = [] image_gride = pyglet.image.ImageGrid(image, 8, 10, item_width=120, item_height=130) self.animationRight = pyglet.image.Animation.from_image_sequence( image_gride[0:10], 0.1, True) self.animationLeft = pyglet.image.Animation.from_image_sequence( image_gride[20:30], 0.1, True) self.sprite = Sprite(self.animationRight) super().add(self.sprite) self.sprite.do(GameAction()) self.schedule(self.update) def update(self, dt): for obj in self.bullets: obj.move() obj.timer() if (obj.terminator()): super().remove(obj.returnSprite()) self.collision_manager.remove_tricky(obj.returnSprite()) self.bullets.remove(obj) def on_key_press(self, symbol, modifiers): if (symbol == key.Z): self.shoot() if (symbol == key.P): self.sprite.position = 100, 600 if (symbol == key.LEFT): self.sprite.image = self.animationLeft def shoot(self): accBullet = bullet(self.sprite.position) super().add(accBullet.returnSprite()) self.collision_manager.add(accBullet.returnSprite()) self.bullets.append(accBullet)
class TestLayer(cocos.layer.Layer): 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))
class Snake(CocosNode): 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 update(self, dt): self.parent.parent.update_score() def add_score(self, s=1): self.score += s
def __init__(self, game_controller): super(WaitLayer, self).__init__() self.game_controller = game_controller bg = Sprite('images/menu/wait_screen.png') bg.position = (400, 300) #player = Sprite(f"images/king_right/1/Fall.png") #player.position = (400, 300) self.add(bg) #self.add(player) self.schedule(self.update)
def make_bubbles(self): # makes bubbles bubbleCount = 10 for i in range(bubbleCount): # make a specific amount of bubbles random.seed() self.new_sprite = Sprite('bubb.png') self.new_sprite.position = random.randint( 10, WINDOW_WIDTH - 10), random.randint(-500, -20) # set position #self.new_sprite.position = -100, -100 self.new_sprite.velocity = random.randint( -30, 30), 1 # set velocity of the bubbles self.new_sprite.do(MoveBubbles()) self.add(self.new_sprite) self.bubbles[i] = self.new_sprite # add them to the array
def __init__(self, name, state=CardState.FACE_UP): image = pyglet.image.load('res/textures/wood3.png') Sprite.__init__(self, image) Tile.__init__(self, name, None, image) # super(Card, self).__init__('res/textures/fabric11.png') # super(Card, self).__init__('res/textures/grass5.png') file_name = 'res/graphes/' + name self.graphe = Sprite(file_name) self.add(self.graphe) self._state = self.set_state(state) self._name = name self._played = False self._edge = [None, None, None, None] self._vertex = [None, None, None, None]
def reinit(self, move): """Происходит реинициализация класса по заданному ходу""" self.bg = Sprite("light95.png") self.bg.scale_x = 0.09 self.bg.scale_y = 0.115 self.bg.position = [self.X_POS, self.Y_POS] chart.Chart().add(self.bg) self.castle = Sprite('castle' + str(move) + '.png') self.castle.scale = 0.8 self.castle.position = [self.X_POS, self.Y_POS] chart.Chart().add(self.castle) self.mas_sprite = [] self.move = [(move-1) if move > 1 else 1, move] self.castle_last_turn = Sprite("castle" + str(self.move[0]) + ".png") self.castle_next_turn = Sprite("castle" + str(self.move[1]) + ".png") self.bg_animation = Sprite("light95.png") self.bg_animation.scale_x = 0.09 self.bg_animation.scale_y = 0.115 chart.Chart().add(self.bg_animation) chart.Chart().add(self.castle_last_turn) chart.Chart().add(self.castle_next_turn) self.bg_animation.opacity = 0 self.castle_next_turn.opacity = 0 self.castle_last_turn.opacity = 0
class Coin(Layer): def __init__(self): super(Coin, self).__init__() w, h = director.get_window_size() self.coins = [ pyglet.resource.image('coins/coin%s.png' % coin_image) for coin_image in range(Coin_image_number) ] self.coin_anim = pyglet.image.Animation.from_image_sequence( self.coins, 0.1, True) self.coin = Sprite(self.coin_anim, (w - 300, h - 50)) def draw(self): self.coin.draw()
def __init__(self): super(WallLayer, self).__init__() self.top = Sprite(pyglet.resource.image('top.png')) self.top.image_anchor = (0, 0) self.top.vx = -200 self.add(self.top) self.bottom = Sprite(pyglet.resource.image('bottom.png')) self.bottom.image_anchor = 0, self.bottom.height self.bottom.vx = -200 self.add(self.bottom) self.reset() self.schedule(self.update)
def __init__(self): super(TitleLayer, self).__init__() logo = Sprite("cnocbs_logo.png", position=(930, 715), scale=0.5, opacity=200) self.add(logo) title = Sprite("title.png", position=(0, 680), anchor=(0, 0), opacity=200) self.add(title)
def __init__(self): super(Actions, self).__init__(52, 152, 219, 1000) # I initialize a sprite using the cocos sprite.Sprite class # Change the path below to whatever your sprite image is self.sprite = Sprite('assets/img/grossini.png') # I set the sprite's position to the center of the screen self.sprite.position = 320, 240 # Here are all the actions I make my sprite perform # Check those class functions for info on how to code them! self.fade_in() self.move_left()
def get_scene(): menu_layer = MultiplexLayer(MainMenu(), ConfigMenu()) # back = BackgroundLayer('bgs/menu_background.jpg') # back_layer.add(back.back_batch()) back_layer = Layer() bg_sprite = Sprite('bgs/menu_background.jpg') bg_sprite.x = bg_sprite.width / 2 bg_sprite.y = bg_sprite.height / 2 back_layer.add(bg_sprite) scene = MainMenuScene() scene.add(back_layer, z=0) # menu_layer.image = 'bgs/menu_background.jpg' scene.add(menu_layer) return scene
class DanceMoveLayer(SpriteLayer): scheduled = False def __init__(self): super().__init__() self.image = pyglet.resource.image("grossini.png") self.sprite = Sprite(self.image) self.add(self.sprite) def do_move(self, move): self.sprite.do(move) def on_enter(self): super().on_enter()
class TestLayer(cocos.layer.Layer): 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 resize(self): director.window.set_size(600, 600)
def setUp(self): Core() gallery = Gallery() self.config = Config() director.init(self.config.window_width, self.config.window_height) self.events = MagicMock() self.sprite_start = Sprite(gallery["button"]["start"]) self.sprite_stop = Sprite(gallery["button"]["stop"]) state_start = ButtonState(sprite=self.sprite_start, event=self.events.start) state_stop = ButtonState(sprite=self.sprite_stop, event=self.events.stop) self.switch = MultiStateButton(states=[state_start, state_stop], scale=0.66)