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))
