Example #1
0
    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)
Example #2
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)
Example #3
0
    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
Example #4
0
    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)
Example #5
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)
Example #6
0
    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")
Example #7
0
	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)))
Example #8
0
 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)
Example #9
0
File: room.py Project: spookyy/hss
    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 )
Example #10
0
    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()
Example #11
0
    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 ) )
Example #12
0
    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 )
Example #13
0
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()
Example #14
0
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()
Example #15
0
	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)
Example #16
0
    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)
        )
Example #17
0
    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()
Example #18
0
    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)
Example #19
0
    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
Example #21
0
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())
Example #23
0
	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()
Example #24
0
 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])
Example #26
0
 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))
Example #27
0
    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 ) )
Example #28
0
    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 ) )
Example #29
0
    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 ) )
Example #30
0
    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))
Example #33
0
    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
Example #35
0
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))
Example #36
0
    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 )
Example #37
0
 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)
Example #38
0
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))
Example #39
0
    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)
Example #40
0
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))
Example #41
0
    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())
Example #44
0
    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
Example #45
0
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)
Example #46
0
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)
Example #47
0
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))
Example #48
0
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
Example #49
0
	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)
Example #50
0
 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
Example #51
0
 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]
Example #52
0
    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
Example #53
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()
Example #54
0
    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)
Example #55
0
    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()
Example #57
0
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
Example #58
0
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()
Example #59
0
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)
Example #60
0
 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)