def run(self): hello_layer = HelloWorld() #main_scene = cocos.scene.Scene(hello_layer, KeyDisplay(), MouseDisplay()) #cocos.director.director.run(main_scene) # start it off at the starting scene #director.run(self.scenes["SPLASH"]) director.run(self.scenes["GAME"])
def test_load_save(): # fix pyglet resource path import os pyglet.resource.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)), '..')) pyglet.resource.reindex() director.init(width=640, height=480) mapname = 'data/testwptmap.json' layer = WptLayer(mapname) wpts = [(0,1),(5,7)] layer.spawn_many(wpts) res=layer.get_wpt_list() ## print 'wpts:',wpts ## print 'res:',res assert(wpts==res) layer.save_private() layer.clear() assert(len(layer.children)==0) assert(layer.modified==False) layer.load_private() reloaded = layer.get_wpt_list() print 'wpts:',wpts print 'reloaded:',res assert(wpts==reloaded) main_scene = cocos.scene.Scene (layer) director.run (main_scene)
def main(): show_common_text() autoscale = True if autoscale: show_mode_1_text() else: show_mode_2_text() director.init(view_width, view_height, autoscale=autoscale) scene = TestScene() world_layer = SquareLand(world_width, world_height) scroller = cocos.layer.ScrollingManager() if autotest: def resize_scroller(): scroller.scale = 0.75 w, h = world_width, world_height template_action = ( Delay(0.05) + CallFunc(world_layer.teleport_player, 0, 0) + Delay(1) + CallFunc(world_layer.teleport_player, w//2, 0) + Delay(1) + CallFunc(world_layer.teleport_player, w//2, h) +Delay(1) + CallFunc(world_layer.teleport_player, w, h) + Delay(1) + CallFunc(resize_scroller) + Delay(1) + CallFunc(director.window.set_size, 800, 600) + CallFunc(world_layer.update_after_change) ) world_layer.do(template_action) scroller.add(world_layer) scene.add(scroller) director.run(scene)
def start(self): self._game_maps = [] self._current_map = None tmx_path_i = os.path.join('assets', 'maps', 'indoor.tmx') tmx_path_o = os.path.join('assets', 'maps', 'field.tmx') self.indoor_tiles_resource = tiles.load(tmx_path_i) self.outdoor_tiles_resource = tiles.load(tmx_path_o) self.collision_manager = CollisionManagerGrid(**constants.collision_params) self.scrolling_manager = ScrollingManager() self.player = self._init_player() self._game_maps.append(GameMap(self.indoor_tiles_resource, self.scrolling_manager, self.collision_manager)) self._game_maps.append(GameMap(self.outdoor_tiles_resource, self.scrolling_manager, self.collision_manager)) self.change_map(0) self._spawn_player() self.add(self.scrolling_manager, z=0) self.add(MessageBox(), name='msg_box', z=2) # there's only one message box in the scene self.schedule(self._current_map.update) self.schedule(self.player.update) director.run(self)
def main(): print(description) director.init(width=sw, height=sh, resizable=True) test_layer = TestLayer() main_scene = cocos.scene.Scene(test_layer) main_scene.add(MouseManager(test_layer)) director.run(main_scene)
def main(): director.init() main_scene = cocos.scene.Scene() main_scene.add( ColorLayer( 255, 0, 0, 255 ) ) main_scene.add( TestLayer() ) main_scene.do( ScaleTo( 0.5, 2 ) ) director.run (main_scene)
def main(): print description director.init() test_layer = TestLayer () main_scene = cocos.scene.Scene (test_layer) director.run (main_scene) print description
def main(): director.init( resizable=True ) main_scene = cocos.scene.Scene() main_scene.add( L() ) director.run( main_scene )
def start_presentation(self): for page in self.pages: page.create(self.desired_size) self.page = self.pages[self.page_num] director.window.set_caption('Presentation: Slide %s'%(self.page_num+1)) self.dispatch_event('on_page_changed', self.page, self.page_num) director.run(self.page)
def main(): print(description) director.init() bg_layer = cocos.layer.ColorLayer(255,0,0,255) test_layer = SwitchLayer() main_scene = cocos.scene.Scene (test_layer) director.run (main_scene)
def start(): director.init(width=CONF.window_width, height=CONF.window_height, caption=CONF.caption) scene = Scene() scene.add(menu.MainMenu(), z=1) director.run(scene)
def test_graph_build(): class TestLayer(TestBedLayer): is_event_handler = True def __init__(self): super( TestBedLayer, self ).__init__() self.vnodes = [] self.add_circle(center,radius) self.add_wpts(list(wps)) fn_visibles = visiblesball_factory(V2(center[0],center[1]),radius) self.wpnav = WaypointNav(wps,fn_visibles) for r,s in zip(wps,self.wpnav.points): assert(geom.dist(r,s)<1.0e-4) print 'self.wpnav.adj[0]:',self.wpnav.adj[0] self.last_i = 0 self.last_j = 0 #add all arcs wpnav = WaypointNav(wps,fn_visibles) points = wpnav.points for i,adj_i in enumerate(wpnav.adj): for j in adj_i: sprites = self.add_line(points[i],points[j]) self.add_named('L%d %d'%(i,j),sprites) # fix pyglet resource path pyglet.resource.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)), '..')) pyglet.resource.reindex() director.init(width=800, height=600) test_layer = TestLayer () main_scene = cocos.scene.Scene (test_layer) director.run (main_scene)
def main(): print description director.init( width=width, height=height, resizable=False ) director.window.set_caption('aspect ratio and fullscreen - see console for usage') scene = cocos.scene.Scene() scene.add(TestLayer()) director.run( scene )
def main(): global keyboard # Declare this as global so it can be accessed within class methods. # Initialize the window. director.init(width=500, height=300, do_not_scale=True, resizable=True) # Create a layer and add a sprite to it. player_layer = layer.Layer() me = sprite.Sprite('human-female.png') player_layer.add(me) # Set initial position and velocity. me.position = (100, 100) me.velocity = (0, 0) # Set the sprite's movement class. me.do(Me()) # Create a scene and set its initial layer. main_scene = scene.Scene(player_layer) # Attach a KeyStateHandler to the keyboard object. keyboard = key.KeyStateHandler() director.window.push_handlers(keyboard) # Play the scene in the window. director.run(main_scene)
def __init__(self,gameController): super(deployView, self).__init__() self.controller = gameController #self.controller.tablero = self.controller.tablero self.add(self.controller.tablero) self.controller.tablero.print_cells() if (not gameController.advancedGame): self.autoDeploy() #director.replace(cocos.scene.Scene(gameView(self.controller))) director.run(cocos.scene.Scene(gameView(self.controller))) if (gameController.advancedGame): self.playerDeploying = self.controller.player1 self.unitsDeployed = 0 self.create_units(self.playerDeploying,1) self.show_deploy_cells(self.playerDeploying) self.selected = None #For debuging issues self.text = cocos.text.Label("Player 1 deploying",font_size=18, x = 400, y = 10, color=(255, 255,255, 255)) self.add(self.text)
def main(): pyglet.clock.schedule(lambda dt: reactor.resume()) pyglet.clock.schedule(anim.add_time) director.init(resizable=True, width=1024, height=768) menu_scene = Scene(HierarchicalMenu(MainMenu())) director.run(menu_scene)
def main(): director.init( resizable=True ) main_scene = cocos.scene.Scene() white = ColorLayer(255,255,255,255) red = ColorLayer(255,0,0,255) blue = ColorLayer(0,0,255,255) green = ColorLayer(0,255,0,255) x, y = director.get_window_size() red.scale = 0.75 blue.scale = 0.5 blue.transform_anchor = 0, 0 green.scale = 0.25 green.transform_anchor = x,y red.add( Sprite( 'grossini.png', (0, y/2) ), z=1 ) blue.add( Sprite( 'grossini.png', (0, y/2) ), z=1 ) green.add( Sprite( 'grossini.png', (0, y/2) ), z=1 ) red.add( Sprite( 'grossini.png', (x, y/2) ), z=1 ) blue.add( Sprite( 'grossini.png', (x, y/2) ), z=1 ) green.add( Sprite( 'grossini.png', (x, y/2) ), z=1 ) main_scene.add( white, z=0 ) main_scene.add( red, z=1 ) main_scene.add( blue, z=2 ) main_scene.add( green, z=3 ) director.run (main_scene)
def main(): global keyboard, scroller director.init(width=800, height=600, autoscale=False, resizable=True) """ car_layer = layer.ScrollableLayer() car = cocos.sprite.Sprite('car.png') car_layer.add(car) car.position = (200, 100) car.max_forward_speed = 200 car.max_reverse_speed = -100 car.do(DriveCar()) """ # scroller.add(car_layer) level_map = tiles.load('test-field.tmx') bg_layer = level_map['bg'] walls_layer = level_map['walls'] scroller = layer.ScrollingManager() scroller.add(bg_layer) scroller.add(walls_layer) main_scene = cocos.scene.Scene(scroller) keyboard = key.KeyStateHandler() director.window.push_handlers(keyboard) """ def on_key_press(key, modifier): if key == pyglet.window.key.Z: if scroller.scale == .75: scroller.do(actions.ScaleTo(1, 2)) else: scroller.do(actions.ScaleTo(.75, 2)) elif key == pyglet.window.key.D: bg_layer.set_debug(True) director.window.push_handlers(on_key_press) """ director.run(main_scene)
def main(): director.init(**resources.settings['window']) scene = Scene() scene.add(MultiplexLayer( MainMenu(scene), LevelSelectMenu(), OptionsMenu(), ScoresLayer(), HelpLayer(), AboutLayer() ), z=1) director.set_show_FPS(resources.settings["general"]["showFps"]) w, h = director.get_window_size() # Music - moved to resources # 1st Try - doesnt play anything # scene.load_music("assets/music.wav") # scene.play_music() # 2nd Try - static noise louder than music # music = pyglet.resource.media("assets/music.wav", streaming = True) # music.play() # 3rd Try - music stops after ca. 1 min (even when piece was longer) # and doesnt repeat as it should # music_player = pyglet.media.Player() # music = pyglet.resource.media("assets/music.wav", streaming = False) # music_player.queue(music) # music_player.eos_action = music_player.EOS_LOOP director.run(scene)
def main(): """ test split layers """ from cocos.scene import Scene from cocos.director import director director.init() window_size = director.get_window_size() window_rect = Rect(0, 0, *window_size) distance = window_size[0] * 3 / 4 main_rect, rest_rect = split_horizontal(window_rect, distance) status_height = 80 status_rect, menu_rect = split_vertical(rest_rect, status_height) main_layer = SplitLayer(main_rect) menu_layer = SplitLayer(menu_rect, color=(255, 255, 0, 255)) status_layer = SplitLayer(status_rect, color=(255, 0, 255, 255)) scene = Scene() scene.add(main_layer, z=0) scene.add(menu_layer, z=1) scene.add(status_layer, z=2) director.run(scene)
def run(self): logger.info("importing") from cocos.director import director from .cocos_scene.graphics import SlideScene from .cocos_scene.control import RemoteControlLayer logger.info("started") director.init(**config.window) if ( config.scale_down ): director.window.set_size(640, 360) if ( config.fullscreen ): director.window.set_fullscreen(True) if ( config.font_files ): for font in config.font_files: pyglet.resource.add_font(font) director.window.set_mouse_visible(False) RemoteControlLayer().set_task(self.task) RemoteControlLayer().set_callback(self._get_callback()) self.slide=OverrideSlide(**config.empty_slide) self.scene=SlideScene(self.slide) director.run(self.scene) # Destroy window if director exits director.window.set_mouse_visible(True) director.window.close() logger.info("ended") #thread.end() return True
def main(): global keyboard, scroller from cocos.director import director director.init(width=600, height=300, do_not_scale=True, resizable=True) car_layer = layer.ScrollableLayer() car = cocos.sprite.Sprite('car.png') car_layer.add(car) car.position = (200, 100) car.max_forward_speed = 200 car.max_reverse_speed = -100 car.do(DriveCar()) scroller = layer.ScrollingManager() test_layer = tiles.load('road-map.xml')['map0'] scroller.add(test_layer) scroller.add(car_layer) main_scene = cocos.scene.Scene(scroller) keyboard = key.KeyStateHandler() director.window.push_handlers(keyboard) def on_key_press(key, modifier): if key == pyglet.window.key.Z: if scroller.scale == .75: scroller.do(actions.ScaleTo(1, 2)) else: scroller.do(actions.ScaleTo(.75, 2)) elif key == pyglet.window.key.D: test_layer.set_debug(True) director.window.push_handlers(on_key_press) director.run(main_scene)
def main(): print description director.init() bg_layer = cocos.layer.ColorLayer(255,0,0,255) test_layer = PrintKey() main_scene = cocos.scene.Scene (bg_layer, test_layer) director.run (main_scene)
def main(): director.init() main_scene = cocos.scene.Scene() main_scene.add( ColorLayer( 255, 0, 0, 255 ) ) main_scene.add( TestLayer() ) main_scene.do( RotateBy( 360, 2 ) ) director.run (main_scene)
def main(): director.init( resizable=True ) main_scene = cocos.scene.Scene() main_scene.add( ColorLayer(0,0,0,255), z=0 ) main_scene.add( L(), z=1 ) director.run( main_scene )
def main(): print "records 6 seconds, snapshots in the tmp subdir" director.set_recorder(25, "tmp/frame-%d.png", 6) director.init() test_layer = TestLayer () main_scene = cocos.scene.Scene (test_layer) director.run (main_scene)
def main(): director.init() test_layer = TestLayer () # note test_layer is NOT in the scene main_scene = cocos.scene.Scene() test_layer.do( RotateBy(360, duration=2) ) director.run (main_scene)
def run(self): debug.msg('Starting game') # Load configuration file self.load_config(util.resource.path('game.conf')) # Create window debug.msg('Creating window') director.init(width=self.config.getint('Graphics', 'screen_width'), height=self.config.getint('Graphics', 'screen_height'), do_not_scale=True, resizable=True, fullscreen=self.config.getboolean('Graphics', 'fullscreen')) director.show_FPS = True debug.msg('Chipmunk version ' + pymunk.chipmunk_version) debug.msg('Pymunk version ' + pymunk.version) # Run game scene scene = gamescene.GameScene() #scene.add(editor.EditorLayer(), z=1) scene.add(gameplay.GameplayLayer(), z=1) debug.msg('Starting game director') director.run(scene) debug.msg('Exiting game')
def main(): global keyboard,projectiles,spawnMax,reloadTime,spawnRate # Declare this as global so it can be accessed within class methods. # Initialize the window. projectiles=[] spawnMax=10 reloadTime=1.0 spawnRate=1.0 director.init(width=1000, height=600, do_not_scale=True, resizable=True) # Create a layer and add a sprite to it. global player_layer player_layer = layer.Layer() spawner = sprite.Sprite('ball.jpg') player_layer.add(spawner) # Set initial position and velocity. spawner.position = (0, randint(0,600)) spawner.velocity = (0, 0) spawner.visible=False # Set the sprite's movement class. spawner.do(Spawner()) # Create a scene and set its initial layer. main_scene = scene.Scene(player_layer) # Attach a KeyStateHandler to the keyboard object. keyboard = key.KeyStateHandler() director.window.push_handlers(keyboard) # Play the scene in the window. director.run(main_scene)
def main(): global keyboard # initialzing the director. the director creates the window for the game director.init(width=400, height= 600, autoscale=True, resizable = True) # creating a layer using the cocos2d platform # different layers are used for each aspect of the game, i.e. the main character or background game_layer = layer.Layer() #creating a Sprite for the main character heroimage = pyglet.resource.image('hero.png') player = HeroShip(heroimage) #heroShip.cshape = cm.AARectShape(eu.Vector2(heroShip.position), 32, 32) #adding the main character to the 'player_layer' layer game_layer.add(player) #initializing the main character's position and velocity #heroShip.position = (100, 100) #heroShip.velocity = (0, 0) #creating a background layer background_layer = layer.Layer() background = sprite.Sprite('space_wallpaper.png') #adding backgound image to background layer background_layer.add(background) AsteroidImage = pyglet.resource.image('asteroid.png') asteroid = Asteroid(AsteroidImage, (200, 400)) #adding asteroids to game layer game_layer.add(asteroid) game_layer.add(CollisionManager(player, asteroid)) #initializing pyglet, which allows for keyboard import for character movement keyboard = key.KeyStateHandler() director.window.push_handlers(keyboard) #assigning the movement class to the heroShip sprite player.do(HeroShipMovement()) #asteroid_1.do(actions.MoveBy( (0, -600), 4) ) #asteroid_2.do(actions.MoveBy( (100, -600), 8) ) main_scene = scene.Scene(background_layer, game_layer) director.run(main_scene)
gameview.get_newgame(), 1.5)) def on_options(self): self.parent.switch_to(1) def on_scores(self): self.parent.switch_to(2) def on_quit(self): pyglet.app.exit() if __name__ == "__main__": pyglet.resource.path.append('data') pyglet.resource.reindex() font.add_directory('data') if sys.platform == 'darwin': director.init(resizable=False, width=600, height=720) else: director.init(autoscale=False, width=600, height=720) scene = Scene() scene.add(MultiplexLayer( MainMenu(), OptionsMenu(), ScoresLayer(), ), z=1) scene.add(BackgroundLayer(), z=0) director.run(scene)
def main(): director.init(caption = "Hallo Cocos2d!") scene = Scene(MainLayer()) director.run(scene)
def main(): director.init(width=600, height=300, do_not_scale=True, resizable=True) main_scene = TestScene() director.run(main_scene)
# and what kind of translation self.skin.do( Animate( anim , recenter_x=self.translate ) ) if __name__ == "__main__": import sys, imp, os p = os.path.abspath(os.path.normpath( os.path.join(os.path.dirname(__file__).replace("\\", "/"), "../data") )) pyglet.resource.path.append(p) pyglet.resource.reindex() director.init() def usage(): return "USAGE:\n"+\ "python animator.py skeleton animation.anim+ \n" +\ " skeleton is a python file with a skeleton variable inside \n"+\ " which has the skeleton you will want to animate\n"+\ " animation.anim+ means a list of animation file names \n"+\ " each of this files will be asigned to a number 1-0" if len(sys.argv)<3: print(usage()) sys.exit() skin_data = imp.load_source("skin", sys.argv[2]).skin sk_file = imp.load_source("skeleton", sys.argv[1]) player = Player(sk_file.skeleton, skin_data, *sys.argv[3:]) director.run(cocos.scene.Scene(player))
# The Jump action requires 4 inputs # 1. How high on the Y axis the sprite should jump # 2. How far on the X axis the sprite should jump to # 3. How many times the sprite should jump # 4. How many seconds it should take for the action to complete self.sprite.do(Jump(50, 0, 1, 1)) # Pretty easy, huh? Now let's do the movement # Once again we overload a default event handler def on_key_press(self, key, modifiers): # First I create a move action because we programmers are lazy and hate having to retype code! move_left = MoveBy((-50, 0), .5) # Here's where that Pyglet symbol_string() function comes in handy # Rather than having to interpret an inconsistent code, I can simply interpret the word LEFT and RIGHT if symbol_string(key) == "LEFT": self.sprite.do(move_left) # Now I need to tell the layer what to do if the user inputs RIGHT if symbol_string(key) == "RIGHT": # This is a pretty awesome feature built into Cocos # I only wrote code for moving left, but I can use the Reverse() function instead of rewriting code # Reverse() simply tells Cocos to do the reverse action of whatever you pass into it. self.sprite.do(Reverse(move_left)) # And once again the same init code director.init() director.run(scene.Scene(InputExample()))
from cocos.director import director from cocos.sprite import Sprite import pyglet class TestLayer(cocos.layer.Layer): def __init__(self): super( TestLayer, self ).__init__() x,y = director.get_window_size() sprite1 = Sprite('grossini.png') sprite1.position = x/2, y/2 sprite1.children_anchor = 0,-100 self.add( sprite1 ) sprite2 = Sprite('grossini.png') sprite2.position = 50,0 sprite1.add( sprite2 ) sprite3 = Sprite('grossini.png') sprite3.position = -50,0 sprite1.add( sprite3 ) if __name__ == "__main__": director.init() test_layer = TestLayer () main_scene = cocos.scene.Scene (test_layer) director.run (main_scene)
def main(): director.init() test_layer = TestBatch() main_scene = cocos.scene.Scene(test_layer) director.show_FPS = True director.run(main_scene)
dest="skin", help="use skin file for skin", default=False, metavar="FILE") (options, args) = parser.parse_args() def usage(): return "python animator.py skeleton.py animation_file.anim" if len(args) != 2: print(usage()) print(parser.error("incorrect number of arguments")) sys.exit() sk_file = imp.load_source("skeleton", args[0]) if options.skin: skin_data = imp.load_source("skin", options.skin).skin options.skin = skin_data animator = Editor(sk_file.skeleton, args[1], options.skin) if options.background: background = cocos.sprite.Sprite(options.background) x, y = director.get_window_size() animator.add(background, z=-10) background.position = x / 2, y / 2 background.scale = float(options.scale) director.run(animator)
from cocos.director import director from State import State from TitleScene import TitleScene class Game: def __init__(self): self.state = State() self.titleScene = TitleScene(self.state) director.init(width=1280, height=720, autoscale=False, caption="Ruin World") director.run(Game().titleScene)
# -*- coding: utf-8 -*- import pyglet.resource from cocos.director import director from rottn.client.scenes.mainMenuScene import MainMenuScene from rottn.client import config from rottn.client import server_manager director.init(caption="ROTTN", fullscreen=False, width=1920, height=1080, vsync=False) pyglet.resource.path = [ "resources/spritesheets", "resources/spritesheets/isometric_hero", ] pyglet.resource.reindex() director.window.set_fullscreen( fullscreen=config.get.screen_mode["fullscreen"], width=config.get.screen_mode["width"], height=config.get.screen_mode["height"], ) director.show_FPS = True director.run(MainMenuScene()) server_manager.clean_up()
def run(self): director.set_show_FPS(True) director.run(self.intro_scene)
class Level1Scene(Scene): def __init__(self): super(Level1Scene, self).__init__() global keyboard, scroller, game_controller, map_layer scroller = ScrollingManager() keyboard = key.KeyStateHandler() director.window.push_handlers(keyboard) map_layer = load("tiles/map1/map_3.tmx")['base'] map_h = (map_layer.cells[-1][-1].y // map_layer.tw + 1) map_layer_bg_0 = load("tiles/map1/map_3.tmx")['background'] map_layer_bg_1 = load("tiles/map1/map_3.tmx")['decorations'] main_layer = MainLayer() scroller.add(map_layer_bg_0, z=-2) scroller.add(map_layer_bg_1, z=-1) scroller.add(map_layer, z=0) scroller.add(main_layer, z=1) self.add(scroller) #self.schedule_interval(main_layer.update, 1 / 60) # 60 times per second if __name__ == '__main__': director.init(resizable=False, width=800, height=600) director.set_depth_test() director.run(Level1Scene())
def main(): global keyboard, scroller, old_ij, old_cell, old_highlighted_color from cocos.director import director director.init(width=600, height=300, autoscale=False, resizable=True) car_layer = layer.ScrollableLayer() car = cocos.sprite.Sprite('car.png') car_layer.add(car) car.position = (200, 100) car.max_forward_speed = 200 car.max_reverse_speed = -100 car.do(DriveCar()) scroller = layer.ScrollingManager() map_loaded = tiles.load('hexmap.tmx') # In Tiled we named 'tile_layer_1' our sample layer test_layer = map_loaded['tile_layer_1'] tint_green_hexmap_borders(test_layer) scroller.add(test_layer) scroller.add(car_layer) old_ij = 'nonexist' old_highlighted_color = None old_cell = None main_scene = cocos.scene.Scene(scroller) keyboard = key.KeyStateHandler() director.window.push_handlers(keyboard) def on_key_press(key, modifier): if key == pyglet.window.key.Z: if scroller.scale == .75: scroller.do(actions.ScaleTo(1, 2)) else: scroller.do(actions.ScaleTo(.75, 2)) elif key == pyglet.window.key.D: test_layer.set_debug(True) elif key == pyglet.window.key.Q: tint_red_hexmap_borders(test_layer) director.window.push_handlers(on_key_press) def on_mouse_motion(x, y, dx, dy): global scroller, old_ij, old_cell, old_highlighted_color #vh, vy = director.get_virtual_coordinates(x, y) vx, vy = scroller.screen_to_world(x, y) ij = test_layer.get_key_at_pixel(vx, vy) if ij == old_ij: return # restore color if old_cell: p, q = old_ij if old_highlighted_color is None: test_layer.set_cell_color(p, q, (255, 255, 255)) del old_cell.properties['color4'] else: test_layer.set_cell_color(p, q, old_highlighted_color[:3]) # record info and set color old_ij = ij i, j = ij print(i, j) old_cell = test_layer.get_cell(i, j) if old_cell is None: return old_highlighted_color = old_cell.properties.get('color4', None) test_layer.set_cell_color(i, j, (255, 0, 0)) director.window.push_handlers(on_mouse_motion) director.run(main_scene)
node.update(dt) for _, node in self.children: if isinstance(node, Actor): self.man_col.add(node) self.collide(self.personaje) #Definimos el método de colisiones def collide(self, node): if node is not None: for other in self.man_col.iter_colliding(node): if self.children.count((1, other)) != 0: other.kill() if isinstance(other, Enemigo): self.HUD.puntos += 10 self.HUD.update() if self.children.count((1, node)) != 0: node.kill() seq = ImageGrid(load('Explosion.png'), 1, 1) anim = Animation.from_image_sequence(seq, 0.05, False) self.sprite = Sprite(anim, (other.x, other.y)) self.add(self.sprite) self.do(Delay(0.8) + CallFunc(self.sprite.kill)) if __name__ == '__main__': ventana = director.init(caption="Videojuego", width=800, height=650) ventana.set_location(300, 50) director.run(Scene(Inicio()))
if __name__ == '__main__': # 全局变量 target_x, target_y = (0, 0) block = [] block_1 = False block_1_R = False block_2 = False speed_3 =100 img_name = "" pygame.mixer.init() # 初始化导演 director.init(width=1201, height=686, caption="BUPT Tower Defence") director.window.pop_handlers() # 键盘 keyboard = key.KeyStateHandler() director.window.push_handlers(keyboard) animation.model2_skin.refresh(load(True,1)[0]) diy_info = load(False,1) animation.diy_skin1.refresh(diy_info[0]) diy_data = [diy_info[1],diy_info[2],diy_info[3]] bg_1 = BG(bg_name="img/start_bg.png") # 1.获取背景图片路径 # people_layer = PeopleLayer() # spr1_layer = Spirite1() # scene_1.add(people_layer, 1) # scene_1.add(spr1_layer, 1) scene_1 = cocos.scene.Scene(bg_1) # 2.把背景图片生成scene scene_1_menu = Main_menu() scene_1.add(scene_1_menu) # 4.把按钮加入到scene director.run(scene_1) # 5.启动场景
def main(): print description director.init() test_layer = TestLayer() main_scene = cocos.scene.Scene(test_layer) director.run(main_scene)
def test(): director.init(resizable=True, width=960, height=640, autoscale=True) director.run(get_game_scene())
def main(): director.init() test_layer = cocos.layer.ColorLayer(255, 0, 0, 255) main_scene = cocos.scene.Scene(test_layer) director.run(main_scene)
self.text_subtitle = pyglet.text.Label( self.subtitle, multiline=True, width=600, font_size=16, x=5, y=director.get_window_size()[1] - 80, anchor_x='left', anchor_y='top', batch=self.batch) self.text_help = pyglet.text.Label( "Press LEFT / RIGHT for prev/next test, " "ENTER to restart test", font_size=16, x=director.get_window_size()[0] // 2, y=20, anchor_x='center', anchor_y='center', batch=self.batch) def draw(self): super(FontLayer, self).draw() self.batch.draw() if __name__ == "__main__": director.init(resizable=True, caption='SuperStepper') director.run(get_steps(1))
def main(): director.init(width=800, height=600) test_layer = TestLayer() main_scene = cocos.scene.Scene(test_layer) director.run(main_scene)
def on_key_press(self, key, modifiers): move_left = MoveBy((-50, 0), .5) move_up = MoveBy((0, 50), .5) if symbol_string(key) == "LEFT": self.sprite.do(move_left) elif symbol_string(key) == "RIGHT": self.sprite.do(Reverse(move_left)) elif symbol_string(key) == "UP": self.sprite.do(move_up) elif symbol_string(key) == "DOWN": self.sprite.do(Reverse(move_up)) elif symbol_string(key) == "SPACE": self.bg_music.stop() coordinates = self.sprite.position if self.trippy: self.do(FadeOutTRTiles(grid=(16, 12), duration=1)) director.replace( scene.Scene(InputLayer(coordinates[0], coordinates[1]))) else: self.stop() director.replace( scene.Scene( InputLayer(coordinates[0], coordinates[1], True))) mixer.init() director.init() director.run(scene.Scene(InputLayer()))
def main(): director.init(width=1920, height=1080, fullscreen=1) test_layer = TestLayer() main_scene = cocos.scene.Scene(test_layer) director.show_FPS = True director.run(main_scene)
self.sprite.x -= 50 * interval elif pyglet.window.key.LEFT in self.keys_held: self.sprite.y = self.sprite.y * interval shooting = pyglet.image.load("C:\sprites\shooting.spritesheet.png") shooting_grid = pyglet.image.ImageGrid(shooting, 3, 1, item_width=60, item_height=70) kick = pyglet.image.load("C:\sprites\kick.spritesheet.png") kick_grid = pyglet.image.ImageGrid(kick, 2, 1, item_width=60, item_height=67) actor_jump = pyglet.image.load("C:\sprites\jump.spritesheet.png") actor_jump_grid = pyglet.image.ImageGrid(actor_jump, 4, 1, item_width=44, item_height=81) actor = pyglet.image.load("C:\sprites\\robot.spritesheet.png") actor_grid = pyglet.image.ImageGrid(actor, 1, 11, item_width=67, item_height=67) mixer.init() director.init(width=1280, height=720, caption="THEGAME2") keyboard = key.KeyStateHandler() director.window.push_handlers(keyboard) director.run(scene.Scene(Background(), Roboto(), AudioLayer()))
# Author: Jonathan Carpenter # Email: [email protected] # Date: 5/30/2016 # File: CrazyPong.py # Description: Starts the game from cocos.director import director from cocos.scene import Scene from mylayers import GameLayer director.init(800, 600) director.run(Scene(GameLayer()))
self.text.element.text = text class Game(Layer): # is_event_handler = True def __init__(self): super(Game, self).__init__() # self.schedule(self.update) # self.pressed = defaultdict(int) # def on_key_press(self, k, m): # self.pressed[k] = 1 # print('Pressed', key.symbol_string(k)) # def on_key_release(self, k, m): # self.pressed[k] = 0 # print('Released', key.symbol_string(k)) # def update(self, dt): # x = self.pressed[key.RIGHT] - self.pressed[key.LEFT] # print(x) director.init(caption='Hello, Cocos', resizable=True, width=800, height=600) director.run(Scene(Game(), KeyDisplay()))
font_name= "Times New Roman", # The next thing we need to input a font. Feel free to replace it with any font you like. font_size=32, # The third input I give is a font size for the text anchor_x= 'center', # This input parameter tells cocos to anchor the text to the middle of the X axis anchor_y= 'center' # Similar to the input above, this parameter tells cocos to anchor the text to the middle of the Y axis ) # Now I need to give the text its position. hello_world_label.position = 320, 240 # Lastly I need to add the label to the layer # self refers to the object, which in this case is the layer self.add(hello_world_label) # From here the code is pretty typical for a Cocos2D application # First I need to initialize the cocos director # The director is the part of cocos that "directs" the scenes. Cocos is pretty partial to this type of film language director.init() # Lastly I run the scene. This line of code is pretty long compared to the others, so I'll explain what each part does # To begin I call the director's run function, which allows it to run the scene by placing layers within director.run( # Next I create a Scene object that allows me to string the layers together. In this case I only have 1 layer scene.Scene( # And lastly I create the layer that we made above inside of the new scene HelloWorld())) # That's it! Run it and see what happens
# coding=<utf-8> from cocos.director import director import pyglet.font import pyglet.resource from MainMenu import new_menu if __name__ == '__main__': pyglet.resource.path.append('assets') pyglet.resource.reindex() pyglet.font.add_file('assets/Oswald-Regular.ttf') director.init(width=1280, height=960, caption='Peaceful Village') director.run(new_menu())
from cocos.sprite import * import pyglet from pyglet.gl import * class BackgroundLayer(cocos.layer.Layer): def __init__(self): super(BackgroundLayer, self).__init__() self.img = pyglet.resource.image('background_image.png') def draw(self): glPushMatrix() self.transform() self.img.blit(0, 0) glPopMatrix() if __name__ == "__main__": director.init(resizable=True) scene1 = cocos.scene.Scene() scene2 = cocos.scene.Scene() colorl = ColorLayer(32, 32, 255, 255) sprite = Sprite('grossini.png', (320, 240)) colorl.add(sprite) scene1.add(BackgroundLayer(), z=0) scene2.add(colorl, z=0) director.run(FadeTransition(scene1, 2, scene2))