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():
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 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 __init__(self, folder):
director.init(
width=800, height=600, caption="Image Viewer", fullscreen=False,
do_not_scale=True, resizable=True
)
bg = BackgroundLayer(0, 0, 0, 255, width=800, height=600)
img = ImageLayer()
info = FileInfoLayer()
self.scene = SingleImageScene()
self.scene.add(bg, z=1, name = "bg")
self.scene.add(img, z=4, name = "img")
self.scene.add(info, z=9, name = "info")
self.scene.push_all_handlers()
self.slideshowController = SlideshowController(folder)
self.slideshowController.add_model_update_handlers(
[bg, img, info]
)
director.window.push_handlers(self.slideshowController)
director.window.push_handlers(bg)
director.window.push_handlers(img)
director.window.push_handlers(info)
print ("INIT >>> SingleImageScene.init()")
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 main():
print(description)
director.init(width=view_width, height=view_height)
scene = cocos.scene.Scene()
city = City()
scene.add(city)
director.run(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():
director.init( resizable=True )
main_scene = cocos.scene.Scene()
main_scene.add( L() )
director.run( main_scene )
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 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 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 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 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():
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():
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)
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():
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 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
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 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():
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 main():
print description
director.init()
test_layer = TestLayer ()
main_scene = cocos.scene.Scene (test_layer)
director.run (main_scene)
print description
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 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():
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():
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 test_new_tower(self):
"""test case when new tower is added without modifying anything in
pause
"""
testtower_name = len(resources.tower) + 1
resources.tower[testtower_name] = {}
for lvl in range(1, 4):
att_dict = eval(
str({'tower': testtower_name, 'lvl': lvl,
'image': 'tower01.png',
'damage': 7, 'range': 200, 'firerate': 2,
'projectileSpeed': 1000, 'cost': 50,
'projectileImage': 'projectile01.png',
'effect': 'normal', 'effectDuration': 5,
'effectFactor': 0}))
try:
att_dict["image"] = resources.load_image("tower01.png")
except FileNotFoundError:
print("Error: Image not found: {}".format("tower01.png"))
try:
att_dict["projectileImage"] = resources.load_image(
"projectile01.png")
except FileNotFoundError:
print("Error: Image not found: {}".format("projectile01.png"))
resources.tower[testtower_name][lvl] = att_dict
director.init(**settings['window'])
pause.PauseLayer.__init__(pause.PauseLayer())
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():
""" Run Intro or Menu"""
director.init(width=800, height=600)
if no_intro :
director.run(menu.Menu())
else:
director.run(intro.IntroScene())
#button down
elif keyboard[key.DOWN] == 1:
if map_arr[px + 1][py] in [2, 3, 4, 5]:
box_n = 'box' + str(map_arr[px + 1][py]) + '_layer'
if map_arr[px + 2][py] == 0:
self.player_layer.move_down()
exec("self." + box_n + ".move_down()")
elif map_arr[px + 1][py] == 1:
pass
elif map_arr[px + 1][py] == 0:
self.player_layer.move_down()
if __name__ == "__main__":
director.init(width=640, height=448, caption="sokoban")
keyboard = key.KeyStateHandler()
director.window.push_handlers(keyboard)
map_arr = []
for i in range(0, 7):
new_line = []
for j in range(0, 10):
new_line += [0]
map_arr += [new_line]
for i in range(0, 10):
map_arr[0][i] = 1
map_arr[6][i] = 1
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
#
import cocos
from cocos.director import director
from cocos.actions import FadeTo
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()
self.sprite = Sprite( 'grossini.png', (x/2, y/2) )
self.add( self.sprite )
self.sprite.do( FadeTo(0, 10 ) )
self.sprite2 = Sprite('grossini.png', (x/4*3,y/2), opacity=0)
self.add( self.sprite2 )
self.sprite2.do( FadeTo(255, 10 ) )
if __name__ == "__main__":
director.init()
test_layer = TestLayer ()
main_scene = cocos.scene.Scene (test_layer)
director.run (main_scene)
#
import cocos
from cocos.director import director
from cocos.actions import *
from cocos.layer 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 )
main_scene = cocos.scene.Scene()
main_scene.add( BackgroundLayer(), z=0 )
main_scene.do( Twirl( twirls=2, center=(320,240), amplitude=1, grid=(32,24), duration=10) )
director.run (main_scene)
def main():
director.init()
test_layer = TestLayer()
main_scene = cocos.scene.Scene(test_layer)
director.run(main_scene)
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with RCr. If not, see <http://www.gnu.org/licenses/>.
import os
from cocos.director import director
import pyglet
from menu import MenuScene
from cups import Cup
import profiles
from game_state import state
director.init(width=1024, height=768, caption="""RCr: Larry's Lawn""")
pyglet.resource.path.extend(['img', os.path.join('cups', 'garden')])
pyglet.resource.reindex()
pyglet.font.add_directory('fonts')
# TODO: non-fixed
state.cup = Cup('garden')
menu_scene = MenuScene()
director.run(menu_scene)
def main():
director.init()
test_layer = TestLayer()
main_scene = cocos.scene.Scene()
main_scene.add(test_layer, name='test_layer')
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.jpeg')
background.position = (200, 300)
#adding backgound image to background layer
background_layer.add(background)
#adding sprites that contain the asteroid images.
# asteroid_1 = sprite.Sprite('asteroid.png')
# asteroid_1.cshape = cm.CircleShape(eu.Vector2(asteroid_1.position), 16)
# asteroid_2 = sprite.Sprite('asteroid_2.png')
# asteroid_2.cshape = cm.CircleShape(eu.Vector2(asteroid_1.position), 16)
# asteroid_1.position = (150, 550)
# asteroid_1.velocity = (0, 1000)
# asteroid_2.position = (200, 550)
# asteroid_2.velocity = (100, 25)
#adding asteroids to game layer
# game_layer.add(asteroid_1)
# game_layer.add(asteroid_2)
#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) )
game_layer2 = GameLayer()
main_scene = scene.Scene(background_layer, game_layer, game_layer2)
director.run(main_scene)
import pyglet.resource
from cocos.director import director
from mainmenu import new_menu
if __name__ == '__main__':
# add images to resource path
pyglet.resource.path.append('assets')
pyglet.resource.reindex()
pyglet.font.add_file('assets/Oswald-Regular.ttf')
director.init(caption='WCTC Defense')
director.run(new_menu())
def main():
director.init(caption="Cocos Invaders", width=800, height=650)
game_layer = GameLayer()
main_scene = Scene(game_layer)
director.run(main_scene)
def main():
director.init(width=600, height=300, do_not_scale=True, resizable=True)
main_scene = TestScene()
director.run(main_scene)
self.hiring.enter_ok(self.entered_cell.town.type_city)
self.hiring.close_window()
self.menu = False
elif self.rules:
self.button_exit = [1063, 74, 1117, 128]
if self.button_exit[0] < x < self.button_exit[2] and \
self.button_exit[1] < y < self.button_exit[3]:
self.rul.close_window()
self.rules = False
window_w, window_h = 1300, 800
if platform == 'darwin':
director.init(width=window_w, height=window_h, fullscreen=True)
else:
director.init(width=window_w, height=window_h)
game_session = session.Session(
4, ["Player 1", "Player 2", "Player 3", "Player 4"])
scene = Scene(MouseDisplay())
scene.add(MultiplexLayer(
menu.MainMenu(),
menu.SavedGames(),
menu.Rules(),
menu.Information(),
menu.NewGame(),
menu.Endgame(),
),
def main():
director.init()
test_layer = cocos.layer.ColorLayer(255, 0, 0, 255)
main_scene = cocos.scene.Scene(test_layer)
director.run(main_scene)
# make a distant point
magi = 1.0 / ((dx * dx + dy * dy)**0.5)
x = px + dx * magi * 99
y = py + dy * magi * 99
return self.__mechanics.raycast(src=(px, py), dst=(x, y))
def __deepcopy__(self, memo):
# the cocos framework does a deepcopy on the action and we need refs, so skip that
return self
class BotAI:
def update(self, cast_laser):
'''
Returns a movement vector
'''
raise NotImplementedError('overwrite this')
if __name__ == '__main__':
if len(sys.argv) != 2:
print('Invalid num of args; syntax is: python {} <ai module name>'.
format(sys.argv[0]))
exit(1)
director.init(width=Main.WIDTH,
height=Main.HEIGHT,
autoscale=True,
resizable=True)
director.run(cocos.scene.Scene(Main()))
def __init__(self):
super().__init__()
bg = cocos.sprite.Sprite("backgroundtest.png")
bg.scale = 2.0
bg.position = bg.width // 2, bg.height // 2
self.px_width = 2400
self.px_height = 2400
self.add(bg)
if __name__ == "__main__":
director.init(width=1280,
height=720,
caption="Tutorial 1: My Cocos Window")
director.window.pop_handlers()
keyboard = key.KeyStateHandler()
director.window.push_handlers(keyboard)
player = Cow1()
bg_layer = Background()
scroller = cocos.layer.ScrollingManager()
scroller.add(bg_layer)
scroller.add(player)
test_scene = cocos.scene.Scene()
test_scene.add(scroller)
def new_game():
director.init(resizable=False, width=1024, height=768)
scene = Scene()
scene.add(BackgroundLayer(), z=0)
scene.add(MultiplexLayer(MainMenu(), ), z=1)
director.run(scene)
def main():
director.init()
test_layer = TestBatch()
main_scene = cocos.scene.Scene(test_layer)
director.show_FPS = True
director.run(main_scene)
def main():
director.init(resizable=True)
interpreter_layer = cocos.layer.PythonInterpreterLayer()
main_scene = cocos.scene.Scene(interpreter_layer)
director.run(main_scene)
def main():
print description
director.init(resizable=True)
scene = get_test_scene()
director.run(scene)
boid = Boid(self.blackboard)
boid.position = (random.randint(0, 200), random.randint(0, 200))
boid.rotation = random.randint(1, 360)
self.add(boid)
boids.append(boid)
return boids
def on_enter(self):
"""Code to run when the Layer enters the scene.
"""
super(BoidLayer, self).on_enter()
self.boids = self.makeBoids()
self.manager.set_focus(0, 0)
if __name__ == "__main__":
import sys
if len(sys.argv) == 2:
how_many = int(sys.argv[1])
else:
how_many = 50
director.init(resizable=True,
caption="Owyl Behavior Tree Demo: Boids",
width=1024,
height=768)
s = Scene(BoidLayer(how_many))
director.run(s)
#! /usr/bin/env python
from cocos.director import director
director.init(width=1024, height=768)
import pyglet
pyglet.resource.path.append('data')
pyglet.resource.reindex()
pyglet.resource.add_font('Prototype.ttf')
from cocos.scene import Scene
from gamelib.ui.splash import splash
director.run(splash())
def run():
director.init()
sample_scene = SampleScene()
director.run(sample_scene)
def main():
font.add_directory('.')
director.init(resizable=True)
director.run(Scene(MainMenu()))
def main():
director.init(width=view_width, height=view_height)
scene = cocos.scene.Scene()
city = City()
scene.add(city)
director.run(scene)
def main():
director.init(caption = "Hello World!", width = 320, height = 240)
scene = Scene(HelloWorld())
director.run(scene)
def main():
print description
director.init()
test_layer = TestLayer()
main_scene = cocos.scene.Scene(test_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)
l.append(MenuItem('New_game', self.new_game))
l.append(MenuItem('Load_game', self._load_game, layer))
l.append(MenuItem('Quit', self.quit))
self.create_menu(l, zoom_in(), zoom_out())
def new_game(self):
new_game(self.map)
def _load_game(self, layer):
sl = Saveload(1280, 720, None, 'load')
layer.add(sl)
self.kill()
def quit(self):
director.pop()
if __name__ == '__main__':
pyglet.resource.path = ['./img']
pyglet.resource.reindex()
director.init(caption='The Lost Books', width=1280, height=720)
director.show_FPS = True
img = pyglet.resource.image('cursor/sword.png', flip_x=True)
img.width, img.height = 40, 40
img.anchor_x, img.anchor_y = 20, 20
cursor = pyglet.window.ImageMouseCursor(img)
director.window.set_mouse_cursor(cursor)
layer = Layer()
director.run(Scene(layer, Main(map_init(), layer=layer)))
self.new = False
r = math.radians(self.rotation)
s = dt * self.speed
new_x = self.x + math.sin(r) * s
new_y = self.y + math.cos(r) * s
tile_properties = test_map.get_at_pixel(new_x, new_y).tile.properties
if not 'collision' in tile_properties:
self.x = new_x
self.y = new_y
scroller.set_focus(self.x, self.y)
if __name__ == '__main__':
director.init(caption='Tank Battle', width=800, height=600)
test_map = tiled2cocos.load_map('map2.tmx')
tank_layer = cocos.tiles.ScrollableLayer()
tank = Tank('tank.png')
tank.x = test_map.px_width // 2
tank.y = test_map.px_height // 2
tank.schedule(tank.update)
tank_layer.add(tank)
scroller = cocos.tiles.ScrollingManager()
scroller.add(test_map)
scroller.add(tank_layer)
keyboard = key.KeyStateHandler()
def main():
director.init(resizable=False, width=1024, height=786)
director.show_FPS = True
title_scene = Scene(MessageDisplay('title'))
director.run(title_scene)
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()))
