def __init__(self):
super(World, self).__init__()
self.player = Car(self)
self.newMap(30, 20)
self.map = tiles.load('tilemap.xml')['map0']
self.checkSpawnPoint()
self.exitPoint = self.checkExitPoint()
self.blockKeys = 0.0
self.blockKeysFull = 0.3
self.bindings = {
key.LEFT: 'left',
key.RIGHT: 'right',
key.UP: 'up',
key.DOWN: 'down',
key.E: 'down_level',
key.Z: 'scale',
}
buttons = {}
for k in self.bindings:
buttons[self.bindings[k]] = 0
self.buttons = buttons
self.overlaidCells = []
#self.overlay = layer.util_layers.ColorLayer(0, 0, 0, 128, 20*128, 30*128)
#self.map.add(self.overlay)
self.carLayer = layer.ScrollableLayer()
self.carLayer.add(self.player)
self.manager = layer.ScrollingManager()
self.manager.add(self.map)
self.manager.add(self.carLayer)
self.add(self.manager)
self.schedule(self.update)
def get_scene():
global keyboard, scroller
keyboard = key.KeyStateHandler()
director.window.push_handlers(keyboard)
model = Model()
world_layer = WorldMap(2000, 2000, model)
scroller = cocos.layer.ScrollingManager()
scroller.add(world_layer)
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.max_forward_speed = 400
car.max_reverse_speed = -200
car.do(DriveCar(model))
scroller.add(car_layer)
scene = Scene()
scene.add(scroller)
return scene
def main():
from cocos.director import director
director.init(width=1200, height=600, autoscale=False, resizable=True)
card_layer = layer.ScrollableLayer()
cards = set()
for i in range(9):
card = cocos.sprite.Sprite('Resources/Box_Orange.png')
card.scale = 1 / 3
card.position = (-100, -100)
cards.add(card)
card_layer.add(card)
ox = 0
oy = 0
t = 1
for c in cards:
c.do(
Delay(t) + Accelerate(
MoveTo((200 + ox, 200 + oy), duration=1)
| RotateBy(720, 1), 3))
if t in (3, 6):
ox = 0
oy += card.height
else:
ox += card.width
t += 1
main_scene = cocos.scene.Scene(card_layer)
director.run(main_scene)
def __init__(self, *args, **kwargs):
super(MyWitch, self).__init__(*args, **kwargs)
self.fullmap = cocos.tiles.load('maps/platformer-map.xml')
# add the walls (labyrinth)
self.walls = self.fullmap['walls']
self.add(self.walls, z=0)
# add the items (bushes cauldron)
self.decoration = self.fullmap['decoration']
self.add(self.decoration, z=1)
# add the player
player_layer = layer.ScrollableLayer()
self.player = cocos.sprite.Sprite('img/witch-standing.png')
self.player.do(MyWitchController())
player_layer.add(self.player)
self.add(player_layer, z=2)
# set the player start position using the player_start token from the map
start = self.decoration.find_cells(player_start=True)[0]
r = self.player.get_rect()
r.midbottom = start.midbottom
self.player.position = r.center
# give a collision handler to the player
mapcollider = cocos.mapcolliders.RectMapCollider(
velocity_on_bump='slide')
self.player.collision_handler = mapcolliders.make_collision_handler(
mapcollider, self.walls)
def main():
global keyboard, scroller
from cocos.director import director
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 = layer.ScrollingManager()
test_layer = tiles.load('road-map.tmx')['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():
global keyboard
global scroller # This variable is going to become a scrolling manager to enable us to scroll along the map
# Initialize director
director.init(width=800, height=600, caption="In the beginning everything was Kay-O", autoscale=True, resizable=True)
# Create player layer and add player onto it
# This time make it a ScrollableLayer type rather than simply Layer
player_layer = layer.ScrollableLayer()
player = sprite.Sprite('images/mr-saturn.png')
player_layer.add(player)
# Sets initial position and velocity of player
player.position = (750, 1200)
player.velocity = (0, 0)
# Set the sprite's movement class
player.do(Player())
# Create a new ScrollingManager object so we can scroll the view along with the player
# The ScrollingManager object lets us separate "world" coordinates and "screen" coordinates
# In this way, we can keep track of where the player is across the entire map but keep the viewport local
#(http://python.cocos2d.org/doc/api/cocos.layer.scrolling.html#cocos.layer.scrolling.ScrollingManager)
scroller = layer.ScrollingManager()
# Now we will create a map layer based on our TMX file
# I called the ground layer "Ground" in the tmx file, which is what we specify here as an identifier
# This is located in the <layer> tags in map.tmx
# We do the same thing for TopLayer
# See README in this folder for more information
ground_layer = tiles.load('tiles/map.tmx')['Ground']
top_layer = tiles.load('tiles/map.tmx')['TopLayer']
# Creates a text layer and adds an instance of BigText() to it
text_layer = BigText()
# Add player sprite and player_layer to the ScrollingManager
# We have also added a second argument to the add() calls
# This is the z-index, which explicity determines the order of layers.
# Here, the player has a z-index of 1 and the text has an index of 2 so it will overlay the player.
# And 0 will be the background
scroller.add(ground_layer, z = 0)
scroller.add(top_layer, z = 1)
scroller.add(player_layer, z = 1)
# Here we initialize the scene with initial layer "scroller" which holds all of the layers
main_scene = scene.Scene(scroller)
# Here we add the text_layer containing the instance of BigText() to the main scene
main_scene.add(text_layer, z = 2)
keyboard = key.KeyStateHandler()
director.window.push_handlers(keyboard)
# Run the scene we've built in the window
director.run(main_scene)
def main():
global keyboard, tilemap, scroller
from cocos.director import director
director.init(width=800, height=600, autoscale=False)
print(description)
# create a layer to put the player in
player_layer = layer.ScrollableLayer()
# NOTE: the anchor for this sprite is in the CENTER (the cocos default)
# which means all positioning must be done using the center of its rect
player = cocos.sprite.Sprite('witch-standing.png')
player_layer.add(player)
player.do(PlatformerController())
# add the tilemaps and the player sprite layer to a scrolling manager
scroller = layer.ScrollingManager()
fullmap = tiles.load('platformer-map.xml')
tilemap_walls = fullmap['walls']
scroller.add(tilemap_walls, z=0)
tilemap_decoration = fullmap['decoration']
scroller.add(tilemap_decoration, z=1)
scroller.add(player_layer, z=2)
# set the player start using the player_start token from the map
start = tilemap_decoration.find_cells(player_start=True)[0]
r = player.get_rect()
# align the mid bottom of the player with the mid bottom of the start cell
r.midbottom = start.midbottom
# player image anchor (position) is in the center of the sprite
player.position = r.center
# give a collision handler to the player
mapcollider = mapcolliders.RectMapCollider(velocity_on_bump='slide')
player.collision_handler = mapcolliders.make_collision_handler(
mapcollider, tilemap_walls)
# construct the scene with a background layer color and the scrolling layers
platformer_scene = cocos.scene.Scene()
platformer_scene.add(layer.ColorLayer(100, 120, 150, 255), z=0)
platformer_scene.add(scroller, z=1)
# track keyboard presses
keyboard = key.KeyStateHandler()
director.window.push_handlers(keyboard)
# allow display info about cells / tiles
def on_key_press(key, modifier):
if key == pyglet.window.key.D:
tilemap_walls.set_debug(True)
director.window.push_handlers(on_key_press)
# run the scene
director.run(platformer_scene)
def main():
global keyboard, walls, scroller
from cocos.director import director
director.init(width=800, height=600, autoscale=False)
print(description)
# create the scrolling manager that will hold all game entities
scroller = layer.ScrollingManager()
# load the map layer of interest and add to the level
walls = tiles.load('tmx_collision.tmx')['walls']
assert isinstance(walls, tiles.TmxObjectLayer)
scroller.add(walls, z=0)
# create a layer to put the player in; it will care for player scroll
player_layer = layer.ScrollableLayer()
# NOTE: the anchor for this sprite is in the CENTER (the cocos default)
# which means all positioning must be done using the center of its rect
player = cocos.sprite.Sprite('witch-standing.png')
player_layer.add(player)
player.do(PlatformerController2())
scroller.add(player_layer, z=1)
# set the player start using the object with the 'player_start' property
player_start = walls.find_cells(player_start=True)[0]
# for convenience the player start was give the same dimensions as player,
# so put player.center over player start center
player.position = player_start.center
# set focus so the player is in view
scroller.set_focus(*player.position)
# extract the player_start, which is not a wall
walls.objects.remove(player_start)
# give a collision handler to the player
mapcollider = mapcolliders.TmxObjectMapCollider()
mapcollider.on_bump_handler = mapcollider.on_bump_slide
player.collision_handler = mapcolliders.make_collision_handler(
mapcollider, walls)
# construct the scene with a background layer color and the scrolling layers
platformer_scene = cocos.scene.Scene()
platformer_scene.add(layer.ColorLayer(100, 120, 150, 255), z=0)
platformer_scene.add(scroller, z=1)
# track keyboard presses
keyboard = key.KeyStateHandler()
director.window.push_handlers(keyboard)
# run the scene
director.run(platformer_scene)
def newLevel(self):
# TODO Make this better
self.killChildren()
self.manager = layer.ScrollingManager()
self.newMap(30, 30)
self.map = tiles.load('tilemap.xml')['map0']
self.checkSpawnPoint()
self.carLayer = layer.ScrollableLayer()
self.carLayer.add(self.player)
self.manager = layer.ScrollingManager()
self.manager.add(self.map)
self.manager.add(self.carLayer)
self.add(self.manager)
def main():
global keyboard, walls, scroller
from cocos.director import director
director.init(width=800, height=600, autoscale=False)
print(description)
# add the tilemap and the player sprite layer to a scrolling manager
scroller = layer.ScrollingManager()
walls = tiles.load('tmx_collision.tmx')['walls']
assert isinstance(walls, tiles.TmxObjectLayer)
scroller.add(walls, z=0)
# make the function to handle collision between actors and walls
mapcollider = TmxObjectMapCollider()
mapcollider.on_bump_handler = mapcollider.on_bump_bounce
fn_collision_handler = mapcolliders.make_collision_handler(
mapcollider, walls)
# make the function to set visual focus at position
fn_set_focus = scroller.set_focus
# create a layer to put the player in
actors_layer = layer.ScrollableLayer()
ball = Ball((300, 300), (600, 600), fn_collision_handler, fn_set_focus,
(255, 0, 255))
actors_layer.add(ball)
scroller.add(actors_layer, z=1)
# set the player start using the object with the 'player_start' property
player_start = walls.find_cells(player_start=True)[0]
ball.position = player_start.center
# set focus so the player is in view
scroller.set_focus(*ball.position)
# extract the player_start, which is not a wall
walls.objects.remove(player_start)
# construct the scene with a background layer color and the scrolling layers
platformer_scene = cocos.scene.Scene()
platformer_scene.add(layer.ColorLayer(100, 120, 150, 255), z=0)
platformer_scene.add(scroller, z=1)
# track keyboard presses
keyboard = key.KeyStateHandler()
director.window.push_handlers(keyboard)
# run the scene
director.run(platformer_scene)
def main():
global keyboard, walls, scroller
from cocos.director import director
director.init(width=800, height=600, autoscale=False)
print(description)
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
worker_action = car.do(DriveCar())
# add the map and the player sprite layer to a scrolling manager
scroller = layer.ScrollingManager()
walls = tiles.load('tmx_collision.tmx')['walls']
assert isinstance(walls, tiles.TmxObjectLayer)
worker_action.walls = walls
scroller.add(walls, z=0)
scroller.add(car_layer, z=1)
player_start = walls.find_cells(player_start=True)[0]
# extract the player_start, which is not a wall
walls.objects.remove(player_start)
# give car access to the walls so it can change colors
car.walls = walls
# construct the scene with a background layer color and the scrolling layers
platformer_scene = cocos.scene.Scene()
platformer_scene.add(layer.ColorLayer(100, 120, 150, 255), z=0)
platformer_scene.add(scroller, z=1)
# track keyboard presses
keyboard = key.KeyStateHandler()
director.window.push_handlers(keyboard)
# run the scene
director.run(platformer_scene)
def main():
global keyboard, tilemap, scroller
from cocos.director import director
director.init(width=800, height=600, do_not_scale=True)
print description
# create a layer to put the player in
player_layer = layer.ScrollableLayer()
# NOTE: the anchor for this sprite is in the CENTER (the cocos default)
# which means all positioning must be done using the center of its rect
player = cocos.sprite.Sprite('witch-standing.png')
player_layer.add(player)
player.do(PlatformerController())
# add the tilemap and the player sprite layer to a scrolling manager
scroller = layer.ScrollingManager()
tilemap = tiles.load('platformer-map.xml')['level0']
scroller.add(tilemap, z=0)
scroller.add(player_layer, z=1)
# set the player start using the player_start token from the tilemap
start = tilemap.find_cells(player_start=True)[0]
r = player.get_rect()
# align the mid bottom of the player with the mid bottom of the start cell
r.midbottom = start.midbottom
# player image anchor (position) is in the center of the sprite
player.position = r.center
# construct the scene with a background layer color and the scrolling layers
platformer_scene = cocos.scene.Scene()
platformer_scene.add(layer.ColorLayer(100, 120, 150, 255), z=0)
platformer_scene.add(scroller, z=1)
# track keyboard presses
keyboard = key.KeyStateHandler()
director.window.push_handlers(keyboard)
# run the scene
director.run(platformer_scene)
def main():
# Declare these as global so they can be accessed within class methods.
global keyboard
global scroller
# Initialize the window.
director.init(width=800, height=600, do_not_scale=True, resizable=True)
# Create a layer and add a sprite to it.
player_layer = layer.ScrollableLayer()
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 scroller object and load tiles.
scroller = layer.ScrollingManager()
map_layer = tiles.load('tiles/map.xml')['map0']
# Add map and player layers.
scroller.add(map_layer)
scroller.add(player_layer)
# Create a scene and set its initial layer.
main_scene = scene.Scene(scroller)
# 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, tilemap, scroller, player_direction, player_right, player_left, my_start_x, ground_list, start_point
from cocos.director import director
director.init(width=BG_WD, height=BG_HT, autoscale=False)
print(description)
# create a layer to put the player in
player_layer = layer.ScrollableLayer(1)
# NOTE: the anchor for this sprite is in the CENTER (the cocos default)
# which means all positioning must be done using the center of its rect
player = cocos.sprite.Sprite('block_man.png')
player.x = -2850
player.y = 120
dragon_keep_bg = cocos.sprite.Sprite('DragonKeepPNG.png')
player_layer.add(dragon_keep_bg, z=1)
player_layer.add(player, z=2)
#test tmx object collision - no really good examples
#points = [(3232, 2400), (4232, 2400), (4232, 2300), (3232, 2300)]
#t = cocos.tiles.TmxObject('polygon', 'dragon', 3232, 2400, 1000, 10, None, None, None, 1, points)
#lay = cocos.tiles.TmxObjectLayer('layer', (255, 0, 0, 255), [t], 1, 1, (3232, 2400))
#i = 0
#pdb.set_trace()
#while (i < 10):
# player.x += 10
# player.y -= 10
# rect = player.get_rect()
# if (lay.collide(rect, 'layer')):
# print("True!")
# i+=1
#tbd
player.do(PlatformerController())
scroller = layer.ScrollingManager()
scroller.add(player_layer, z=2)
# construct the scene with a background layer color and the scrolling layers
platformer_scene = cocos.scene.Scene()
platformer_scene.add(layer.ColorLayer(0, 0, 0, 255), z=0)
platformer_scene.add(scroller, z=1)
# track keyboard presses
keyboard = key.KeyStateHandler()
director.window.push_handlers(keyboard)
my_start_x = 0
ground_list = []
start_point = []
# allow display info about cells / tiles
def on_key_press(key, modifier):
#pdb.set_trace()
global player_direction
if key == pyglet.window.key.LEFT:
player.x -= 100
if key == pyglet.window.key.RIGHT:
player.x += 100
if key == pyglet.window.key.UP:
player.y += 100
if key == pyglet.window.key.DOWN:
player.y -= 100
if key == pyglet.window.key.E:
print(ground_list)
scroller.set_focus(player.position[0], player.position[1])
print(player.position)
print("x{}, y{}".format(player.x, player.y))
def on_mouse_release(x, y, buttons, modifiers):
global my_start_x, start_point, ground_list
t = scroller.screen_to_world(x, y)
print("mouse x{}, y{}".format(x, y))
print("mouse x{}, y{}".format(t[0], t[1]))
if (my_start_x == 0):
print("start_x = 0")
my_start_x = 1
start_point = t
else:
print("start_x = 1")
my_start_x = 0
ground_list.append([start_point, t])
director.window.push_handlers(on_key_press)
director.window.push_handlers(on_mouse_release)
scroller.set_focus(player.position[0], player.position[1])
# run the scene
director.run(platformer_scene)
def loadSceenShowing(self):
self.levelData = tiles.load(self.level.datapath)
self.tilemap_decorations = self.levelData["decorations"]
self.tilemap_walls = self.levelData["walls"]
self.layers = [self.tilemap_decorations, self.tilemap_walls]
self.layers[0].visible = False
self.layers[1].visible = True
setattr(self.layers[0], "name", "Decorations Layer")
setattr(self.layers[1], "name", "Walls Layer")
if isinstance(self.level.background, str):
self.bgLayer = layer.ScrollableLayer()
self.bgLayer.parallax = 0.5
bgImage = cocos.sprite.Sprite(self.level.background)
# TODO: Add code to scale image to viewport, then tile it
self.bgLayer.add(bgImage)
self.scrollerViewport = rect.Rect(0, int(resheight * 0.12),
int(reswidth), int(resheight * 0.76))
self.scroller = self.LevelEditorScrollManager(self.scrollerViewport,
True)
self.scroller.autoscale = False
#self.scroller.on_cocos_resize = on_cocos_resize
self.scroller.scale = 0.8
self.scroller.viewport = cocos.rect.Rect(0, int(resheight * 0.12),
int(reswidth),
int(resheight * 0.76))
#self.scroller.x = 0
#self.scroller.y = 0
self.scroller.add(self.tilemap_decorations, z=-1)
self.scroller.add(self.tilemap_walls, z=0)
self.gridLayer = LevelGridLayer(walls=self.tilemap_walls,
decorations=self.tilemap_decorations,
scroller=self.scroller,
level=self.level)
self.scroller.add(self.gridLayer, z=1)
self.add(self.bgLayer, z=-5)
self.add(self.scroller)
self.headerLayer = layer.ColorLayer(0,
0,
0,
175,
width=int(reswidth),
height=int(resheight * 0.12))
self.headerLayer.x = 0
self.headerLayer.y = resheight - self.headerLayer.height
self.title = text.Label("Level Editor",
font_name=resources.font[1],
font_size=50,
anchor_y="center",
anchor_x="center")
self.title.x = int(self.headerLayer.width / 2)
self.title.y = int(self.headerLayer.height / 2)
self.backButton = elements.mediumButton(
"BACK", events.leveleditorevents.leveleditorGoBack)
self.backButton.x = int(self.headerLayer.width * 0.065)
self.backButton.y = int(self.headerLayer.height / 2)
self.saveButton = elements.mediumButton(
"SAVE", events.leveleditorevents.levelSave)
self.saveButton.x = int(self.headerLayer.width * 0.947)
self.saveButton.y = int(self.headerLayer.height / 2)
self.discardButton = elements.mediumButton(
"DISCARD", events.leveleditorevents.levelDiscard)
self.discardButton.lbl.element.font_size = 13
self.discardButton.x = int(self.headerLayer.width * 0.857)
self.discardButton.y = int(self.headerLayer.height / 2)
#self.editButton
self.add(self.headerLayer, z=2)
self.headerLayer.add(self.title)
self.headerLayer.add(self.saveButton)
self.headerLayer.add(self.backButton)
self.headerLayer.add(self.discardButton)
self.backButton.px = self.saveButton.px = self.discardButton.px = self.headerLayer.x
self.backButton.py = self.saveButton.py = self.discardButton.py = self.headerLayer.y
self.backButton.show(0.1)
self.footerLayer = layer.ColorLayer(0,
0,
0,
125,
width=int(reswidth),
height=int(resheight * 0.12))
self.footerLayer.x = 0
self.footerLayer.y = 0
self.add(self.footerLayer, z=2)
self.upButton = elements.smallButton("\u2b9d", self.moveUp)
self.rightButton = elements.smallButton("\u2b9e", self.moveRight)
self.leftButton = elements.smallButton("\u2b9c", self.moveLeft)
self.downButton = elements.smallButton("\u2b9f", self.moveDown)
self.upButton.x = self.footerLayer.width * 0.92
self.upButton.y = self.footerLayer.height * 0.75
self.rightButton.x = self.footerLayer.width * 0.955
self.rightButton.y = self.footerLayer.height * 0.5
self.leftButton.x = self.footerLayer.width * 0.885
self.leftButton.y = self.footerLayer.height * 0.5
self.downButton.x = self.footerLayer.width * 0.92
self.downButton.y = self.footerLayer.height * 0.25
self.itemRows = ItemPackRows()
self.activeLayerSelection = ActiveLayerSelection()
self.activeLayerSelection.changeLabel.element.text = self.layers[
1].name
self.footerLayer.add(self.upButton)
self.footerLayer.add(self.rightButton)
self.footerLayer.add(self.leftButton)
self.footerLayer.add(self.downButton)
self.footerLayer.add(self.itemRows)
self.footerLayer.add(self.activeLayerSelection)
self.upButton.show(0.1)
self.rightButton.show(0.1)
self.leftButton.show(0.1)
self.downButton.show(0.1)
self.scroller.set_focus(int(self.tilemap_walls.view_w / 2),
int(self.tilemap_walls.view_h / 2))
self.scrollerFocusLimits = {
"up": 0,
"down": int(self.tilemap_walls.view_h / 2),
"left": int(self.tilemap_walls.view_w / 2),
"right": 0
}
self.intro.do(cocos.actions.Delay(3) + cocos.actions.FadeOut(1))
self.intro.title.do(cocos.actions.Delay(3) + cocos.actions.FadeOut(1))
self.intro.desc.do(cocos.actions.Delay(3) + cocos.actions.FadeOut(1))
def main():
global keyboard, scroller
from cocos.director import director
director.init(width=800, height=600, autoscale=False, resizable=True)
global startAction, doTask, isPack, cel, ruch, isPicked, packAdres
scroller = layer.ScrollingManager()
test_layer = tiles.load('mapaSZI.tmx')['Warstwa Kafelków 1']
obj = tiles.load('mapa.tmx')['GameObjects']
poi = tiles.load('mapa.tmx')['Points']
scroller.add(test_layer)
#0=start, 1=up, 2=bottom 3=bottom1,
#0=wojtyniaka, 1=mickiewicza, 2=kopernika, 3=orlicza, 4= kuchnia, 5=borsuka
kelner_layer = layer.ScrollableLayer()
kelner = cocos.sprite.Sprite('kelner.png')
kelner_layer.add(kelner)
miejsca = {}
startX = poi.objects[0].x
startY = poi.objects[0].y
miejsca['start'] = (startX, startY)
upX = poi.objects[1].x
upY = poi.objects[1].y
miejsca['up'] = (upX, upY)
bottomX = poi.objects[2].x
bottomY = poi.objects[2].y
miejsca['bottom'] = (bottomX, bottomY)
bottom1X = poi.objects[3].x
bottom1Y = poi.objects[3].y
miejsca['bottom1'] = (bottom1X, bottom1Y)
stacjaX = obj.objects[0].x
stacjaY = obj.objects[0].y
miejsca['stacja'] = (stacjaX, stacjaY)
micX = obj.objects[1].x
micY = obj.objects[1].y
miejsca['mickiewicza'] = (micX, micY)
kopX = obj.objects[2].x
kopY = obj.objects[2].y
miejsca['kopernika'] = (kopX, kopY)
orlX = obj.objects[3].x
orlY = obj.objects[3].y
miejsca['orlicza'] = (orlX, orlY)
pasX = obj.objects[4].x
pasY = obj.objects[4].y
miejsca['pascala'] = (pasX, pasY)
borX = obj.objects[5].x
borY = obj.objects[5].y
miejsca['borsuka'] = (borX, borY)
G = Graf()
G.add_vertex('start')
G.add_vertex('mickiewicza')
G.add_vertex('up')
G.add_vertex('borsuka')
G.add_vertex('bottom1')
G.add_vertex('stacja')
G.add_vertex('pascala')
G.add_vertex('orlicza')
G.add_vertex('bottom')
G.add_vertex('kopernika')
G.add_edge('start', 'mickiewicza', 9)
G.add_edge('mickiewicza', 'up', 2)
G.add_edge('up', 'borsuka', 2)
G.add_edge('borsuka', 'bottom1', 4)
G.add_edge('bottom1', 'stacja', 1)
G.add_edge('bottom1', 'pascala', 3)
G.add_edge('pascala', 'orlicza', 5)
G.add_edge('orlicza', 'bottom', 3)
G.add_edge('bottom', 'kopernika', 3)
G.add_edge('kopernika', 'start', 3)
G.add_edge('mickiewicza', 'start', 9)
G.add_edge('up', 'mickiewicza', 2)
G.add_edge('borsuka', 'up', 2)
G.add_edge('bottom1', 'borsuka', 4)
G.add_edge('stacja', 'bottom1', 1)
G.add_edge('pascala', 'bottom1', 3)
G.add_edge('orlicza', 'pascala', 5)
G.add_edge('bottom', 'orlicza', 3)
G.add_edge('kopernika', 'bottom', 3)
G.add_edge('start', 'kopernika', 3)
print(shortest_path(G, 'mickiewicza', 'pascala'))
short = shortest_path(G, 'mickiewicza', 'pascala')
kelner.position = miejsca['start']
kelner.rotation = 90
ruch = MoveTo(miejsca['start'], 0)
for i in short:
ruch += MoveTo(miejsca[i], 2)
kelner.do(ruch)
scroller.add(kelner_layer)
main_scene = cocos.scene.Scene(scroller)
director.run(main_scene)
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)
for x in range(len(self.squares_matrix)):
if self.squares_matrix[x][y] is None:
row += ' |'
else:
row += '*|'
s = row + '\n' + s
if label is not None:
s = label + '\n' + s
return s
class ShouldntHappenError(UserWarning):
pass
#===============================================================================
#=========== MAIN SCRIPT ================
#===============================================================================
if __name__ == '__main__':
director.init(resizable=True)
tetris_board = TetrisBoardLayer('tetris.xml')
scroller = layer.ScrollingManager()
scroller.set_focus(100, 200)
scroller.add(tetris_board)
s = layer.ScrollableLayer()
scroller.add(s)
director.run(scene.Scene(scroller))
