def formatTerr(self, worldTerritories, territorySprites,
highlightedTerritories, gui, colorTerritories, textList,
map):
for i, j in enumerate(worldTerritories):
surface = pygame.image.load(j).convert()
resize = c.windowLength / surface.get_width()
surface = pygame.transform.scale(
surface, (int(resize * surface.get_width()),
int(resize * surface.get_height())))
territorySprite = Sprites(surface, j)
initialSpriteLayer = Sprites(surface.copy(), j)
gui.setSurfaceColor(initialSpriteLayer, (1, 1, 1), 150)
territorySprites.append(territorySprite)
highlightedTerritories.append(initialSpriteLayer)
# Creates final layer of all connected sprites
colorTerritories(territorySprites, gui)
for i, j in enumerate(territorySprites):
if i == 0:
finalLayout = j.layout.copy()
else:
finalLayout.blit(j.layout, (0, 0))
# Update visual troop numbers
gui.troopDisplay(textList, territorySprites, map)
return finalLayout
def __init__(self, canvas, parent=None, colors=['#A0FFA0', '#FF8080']):
self._activity = parent
self._colors = [colors[0]]
self._colors.append(colors[1])
self._canvas = canvas
if parent is not None:
parent.show_all()
self._parent = parent
self._canvas.set_flags(gtk.CAN_FOCUS)
self._canvas.connect("expose-event", self._expose_cb)
self._width = gtk.gdk.screen_width()
self._height = gtk.gdk.screen_height() - (GRID_CELL_SIZE * 1.5)
self._scale = self._width / (10 * DOT_SIZE * 1.2)
self._dot_size = int(DOT_SIZE * self._scale)
self._space = int(self._dot_size / 5.)
self.max_levels = len(LEVELS_TRUE)
self.this_pattern = False
# Generate the sprites we'll need...
self._sprites = Sprites(self._canvas)
self._dots = []
self._generate_grid()
def __init__(self, canvas, parent=None, colors=['#A0FFA0', '#FF8080']):
self._activity = parent
self._colors = [colors[0]]
self._colors.append(colors[1])
self._colors.append('#D0D0D0')
self._colors.append('#000000')
self._canvas = canvas
if parent is not None:
parent.show_all()
self._parent = parent
self._canvas.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
self._canvas.connect("draw", self.__draw_cb)
self._canvas.connect("button-press-event", self._button_press_cb)
self._width = Gdk.Screen.width()
self._height = Gdk.Screen.height() - (GRID_CELL_SIZE * 1.5)
self._scale = self._width / (10 * DOT_SIZE * 1.2)
self._dot_size = int(DOT_SIZE * self._scale)
self._space = int(self._dot_size / 5.)
self.we_are_sharing = False
self._edge = 4
self._move_list = []
# Generate the sprites we'll need...
self._sprites = Sprites(self._canvas)
self._dots = []
self._generate_grid()
def _setup_workspace(self):
''' Add the bones. '''
self._width = Gdk.Screen.width()
self._height = int(Gdk.Screen.height() - (GRID_CELL_SIZE * 2))
self._scale = self._height * 1.0 / BONE_HEIGHT
self._bone_width = int(BONE_WIDTH * self._scale)
self._bone_height = int(BONE_HEIGHT * self._scale)
# Generate the sprites we'll need...
self._sprites = Sprites(self._canvas)
self._bone_index = Sprite(
self._sprites, 0, 0,
_load_svg_from_file(
os.path.join(self._bone_path, 'bones-index.svg'),
self._bone_width, self._bone_height))
self._max_bones = int(self._width / self._bone_width) - 1
self._blank_image = _load_svg_from_file(
os.path.join(self._bone_path, 'blank-bone.svg'), self._bone_width,
self._bone_height)
for bones in range(self._max_bones):
self._bones.append(
Sprite(self._sprites, bones * self._bone_width, 0,
self._blank_image))
circle_image = _load_svg_from_file(
os.path.join(self._bone_path, 'circle.svg'), int(self._scale * 45),
int(self._scale * 45))
self._circles[0] = Sprite(self._sprites, 0, -100, circle_image)
self._circles[1] = Sprite(self._sprites, 0, -100, circle_image)
oval_image = _load_svg_from_file(
os.path.join(self._bone_path, 'oval.svg'), int(self._scale * 129),
int(self._scale * 92))
for bones in range(self._max_bones - 1):
self._ovals.append(Sprite(self._sprites, 0, -100, oval_image))
def __init__(self, canvas, parent=None, colors=['#A0FFA0', '#FF8080']):
self._activity = parent
self._colors = [colors[0]]
self._colors.append(colors[1])
self._mun_color = MunColor()
self._dot_cache = {}
self._canvas = canvas
if parent is not None:
parent.show_all()
self._parent = parent
self._canvas.connect("draw", self.__draw_cb)
self._width = Gdk.Screen.width()
self._height = Gdk.Screen.height() - (GRID_CELL_SIZE * 1.5)
self._scale = self._width / (10 * DOT_SIZE * 1.2)
self._dot_size = int(DOT_SIZE * self._scale)
self._space = int(self._dot_size / 5.)
self.max_levels = len(LEVELS_TRUE)
self.this_pattern = False
# Generate the sprites we'll need...
self._sprites = Sprites(self._canvas)
self._dots = []
self._generate_grid()
def __init__(self, canvas, parent=None, path=None,
colors=['#A0FFA0', '#FF8080']):
self._canvas = canvas
self._parent = parent
self._parent.show_all()
self._path = path
self.level = 1
self._colors = ['#FFFFFF']
self._colors.append(colors[0])
self._colors.append(colors[1])
self._colors.append(colors[0])
self._colors.append('#FF0000')
self._canvas.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
self._canvas.connect("draw", self.__draw_cb)
self._canvas.connect("button-press-event", self._button_press_cb)
self._width = Gdk.Screen.width()
self._height = Gdk.Screen.height() - GRID_CELL_SIZE
if self._width < self._height:
self.portrait = True
self.grid_height = TEN
self.grid.width = SEVEN
else:
self.portrait = False
self.grid_height = SEVEN
self.grid_width = TEN
self._scale = min(self._width / (self.grid_width * DOT_SIZE * 1.2),
self._height / (self.grid_height * DOT_SIZE * 1.2))
self._dot_size = int(DOT_SIZE * self._scale)
self._space = int(self._dot_size / 5.)
self.we_are_sharing = False
# '-1' Workaround for showing 'second 0'
self._game_time_seconds = -1
self._game_time = "00:00"
self._timeout_id = None
# Generate the sprites we'll need...
self._sprites = Sprites(self._canvas)
self._dots = []
for y in range(self.grid_height):
for x in range(self.grid_width):
xoffset = int((self._width - self.grid_width * self._dot_size -
(self.grid_width - 1) * self._space) / 2.)
self._dots.append(
Sprite(self._sprites,
xoffset + x * (self._dot_size + self._space),
y * (self._dot_size + self._space),
self._new_dot(self._colors[0])))
self._dots[-1].type = 0 # not set
self._dots[-1].set_label_attributes(40)
self._all_clear()
Gdk.Screen.get_default().connect('size-changed', self._configure_cb)
def __init__(self, canvas, parent=None, colors=['#A0FFA0', '#FF8080']):
self._activity = parent
self._colors = colors
self._canvas = canvas
parent.show_all()
self._canvas.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
self._canvas.connect("draw", self.__draw_cb)
self._canvas.connect("button-press-event", self._button_press_cb)
self._width = Gdk.Screen.width()
self._height = Gdk.Screen.height() - (GRID_CELL_SIZE * 1.5)
self._scale = self._height / (14.0 * DOT_SIZE * 1.2)
self._dot_size = int(DOT_SIZE * self._scale)
self._turtle_offset = 0
self._space = int(self._dot_size / 5.)
self._orientation = 0
self.level = 0
self.custom_strategy = None
self.strategies = [
BEGINNER_STRATEGY, INTERMEDIATE_STRATEGY, EXPERT_STRATEGY,
self.custom_strategy
]
self.strategy = self.strategies[self.level]
self._timeout_id = None
# Generate the sprites we'll need...
self._sprites = Sprites(self._canvas)
self._dots = []
for y in range(THIRTEEN):
for x in range(THIRTEEN):
xoffset = int((self._width - THIRTEEN * (self._dot_size + \
self._space) - self._space) / 2.)
if y % 2 == 1:
xoffset += int((self._dot_size + self._space) / 2.)
if x == 0 or y == 0 or x == THIRTEEN - 1 or y == THIRTEEN - 1:
self._dots.append(
Sprite(self._sprites,
xoffset + x * (self._dot_size + self._space),
y * (self._dot_size + self._space),
self._new_dot('#B0B0B0')))
else:
self._dots.append(
Sprite(self._sprites,
xoffset + x * (self._dot_size + self._space),
y * (self._dot_size + self._space),
self._new_dot(self._colors[FILL])))
self._dots[-1].type = False # not set
# Put a turtle at the center of the screen...
self._turtle_images = []
self._rotate_turtle(self._new_turtle())
self._turtle = Sprite(self._sprites, 0, 0, self._turtle_images[0])
self._move_turtle(self._dots[int(THIRTEEN * THIRTEEN / 2)].get_xy())
# ...and initialize.
self._all_clear()
def __init__(self, x, y, xvel):
Entity.__init__(self)
# Create Surface Area
self.image = pygame.Surface((90, 90), pygame.SRCALPHA)
self.rect = pygame.Rect(0, 0, 80, 80)
# Initialize variables
self.xvel = xvel
self.yvel = 0
self.rect.x = x
self.rect.y = y
self.boundary_left = 0
self.boundary_right = 1000
# States
self.onGround = False
self.airborne = True
self.destroyed = False
self.faceright = True
self.counter = 0
# Load Sprites
sprites = Sprites("bat8.png")
image = sprites.get_image(15, 9, 67, 73)
color_switch = image.get_at((0, 0))
image.set_colorkey(color_switch)
self.walkleft.append(image)
image = pygame.transform.flip(image, True, False)
self.walkright.append(image)
sprites = Sprites("bat9.png")
image = sprites.get_image(18, 11, 73, 69)
color_switch = image.get_at((0, 0))
image.set_colorkey(color_switch)
self.walkleft.append(image)
image = pygame.transform.flip(image, True, False)
self.walkright.append(image)
sprites = Sprites("bat10.png")
image = sprites.get_image(20, 26, 59, 35)
color_switch = image.get_at((0, 0))
image.set_colorkey(color_switch)
self.walkleft.append(image)
image = pygame.transform.flip(image, True, False)
self.walkright.append(image)
def __init__(self, misc):
Entity.__init__(self)
misc_list = Sprites("heart.png")
image = misc_list.get_image(0, 0, 48, 48)
color_switch = image.get_at((0, 0))
self.image = misc_list.get_image(misc[0], misc[1], misc[2], misc[3])
self.image.set_colorkey(color_switch)
self.rect = self.image.get_rect()
def __init__(self, misc):
pygame.sprite.Sprite.__init__(self)
misc_list = Sprites("heart2.png")
image = misc_list.get_image(0, 0, 1, 1)
color_switch = image.get_at((0, 0))
self.image = misc_list.get_image(misc[0], misc[1], misc[2], misc[3])
self.image.set_colorkey(color_switch)
self.rect = self.image.get_rect()
def __init__(self, canvas, parent=None, colors=['#A0FFA0', '#FF8080']):
self._activity = parent
self.colors = colors
# Starting from command line
if parent is None:
self._running_sugar = False
self._canvas = canvas
else:
self._running_sugar = True
self._canvas = canvas
parent.show_all()
self._canvas.set_can_focus(True)
self._canvas.add_events(Gdk.EventMask.BUTTON_PRESS_MASK
| Gdk.EventMask.BUTTON_RELEASE_MASK
| Gdk.EventMask.POINTER_MOTION_MASK)
self._canvas.connect("draw", self._draw_cb)
self._canvas.connect("button-press-event", self._button_press_cb)
self._canvas.connect("button-release-event", self._button_release_cb)
self._canvas.connect("motion-notify-event", self._mouse_move_cb)
self._canvas.connect("key_press_event", self._keypress_cb)
self._width = Gdk.Screen.width()
self._height = Gdk.Screen.height() - (GRID_CELL_SIZE * 1.5)
self._scale = self._height / (8.0 * TILE_HEIGHT)
self.tile_width = TILE_WIDTH * self._scale
self.tile_height = TILE_HEIGHT * self._scale
# Generate the sprites we'll need...
self._sprites = Sprites(self._canvas)
self.grid = Grid(self._sprites, self._width, self._height,
self.tile_width, self.tile_height, self._scale,
colors[0])
self.deck = Deck(self._sprites, self._scale, colors[1])
self.deck.board.move((self.grid.left, self.grid.top))
self.hands = []
self.hands.append(Hand(self.tile_width, self.tile_height))
self._errormsg = []
for i in range(4):
self._errormsg.append(error_graphic(self._sprites))
self._highlight = highlight_graphic(self._sprites, self._scale)
self._score_card = blank_tile(self._sprites,
scale=self._scale * 2,
color=colors[1])
self._score_card.set_label_attributes(64)
self._score_card.move(((int(self._width / 2) - self.tile_width),
int(self._height / 2) - self.tile_height))
# and initialize a few variables we'll need.
self.buddies = []
self._my_hand = MY_HAND
self.playing_with_robot = False
self._all_clear()
def __init__(self, sprite_sheet_data):
pygame.sprite.Sprite.__init__(self)
sprite_sheet = Sprites("scifi_platformTiles_32x32.png")
self.image = sprite_sheet.get_image(sprite_sheet_data[0],
sprite_sheet_data[1],
sprite_sheet_data[2],
sprite_sheet_data[3])
self.rect = self.image.get_rect()
def __init__(self, enemies):
pygame.sprite.Sprite.__init__(self)
enemy_list = Sprites("spikez.png")
image = enemy_list.get_image(0, 0, 1, 1)
color_switch = image.get_at((0, 0))
self.image = enemy_list.get_image(enemies[0], enemies[1], enemies[2],
enemies[3])
self.image.set_colorkey(color_switch)
self.rect = self.image.get_rect()
def __init__(self, coins):
pygame.sprite.Sprite.__init__(self)
coin_list = Sprites("coin_silver.png")
image = coin_list.get_image(0, 0, 1, 1)
color_switch = image.get_at((0, 0))
self.image = coin_list.get_image(coins[0], coins[1], coins[2],
coins[3])
self.image.set_colorkey(color_switch)
self.rect = self.image.get_rect()
def __init__(self, player, game):
Entity.__init__(self)
# Append sprites
sprites = Sprites("proj1.png")
image = sprites.get_image(6, 6, 35, 13)
self.projectileR.append(image)
image = pygame.transform.flip(image, True, False)
self.projectileL.append(image)
sprites = Sprites("proj2.png")
image = sprites.get_image(6, 8, 35, 9)
self.projectileR.append(image)
image = pygame.transform.flip(image, True, False)
self.projectileL.append(image)
sprites = Sprites("proj3.png")
image = sprites.get_image(6, 8, 35, 9)
self.projectileR.append(image)
image = pygame.transform.flip(image, True, False)
self.projectileL.append(image)
sprites = Sprites("proj4.png")
image = sprites.get_image(6, 7, 35, 9)
self.projectileR.append(image)
image = pygame.transform.flip(image, True, False)
self.projectileL.append(image)
self.player = player
self.xvel = 5
self.castright = player.faceright
self.image = self.projectileR[0]
self.rect = self.image.get_rect()
self.rect.y = (
(self.player.rect.top + self.player.rect.bottom) / 2) - 10
if self.castright == True:
self.rect.x = self.player.rect.x + 55
if self.castright == False:
self.xvel *= -1
self.rect.x = player.rect.left - 55
self.image = self.projectileL[0]
def __init__(self, canvas, parent=None, mycolors=['#A0FFA0', '#FF8080']):
self._activity = parent
self.colors = [mycolors[0]]
self.colors.append(mycolors[1])
self._canvas = canvas
if parent is not None:
parent.show_all()
self._parent = parent
self._canvas.connect("draw", self.__draw_cb)
self._canvas.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
self._canvas.connect("button-press-event", self._button_press_cb)
self._canvas.add_events(Gdk.EventMask.BUTTON_RELEASE_MASK)
self._canvas.connect('button-release-event', self._button_release_cb)
self._canvas.add_events(Gdk.EventMask.POINTER_MOTION_MASK)
self._canvas.connect("motion-notify-event", self._mouse_move_cb)
self._width = Gdk.Screen.width()
self._height = Gdk.Screen.height() - GRID_CELL_SIZE
self._scale = self._width / 1200.
self.press = None
self.dragpos = [0, 0]
self.startpos = [0, 0]
self._dot_cache = {}
self._xo_cache = {}
self._radius = 22.5
self._stroke_width = 9.5
# Generate the sprites we'll need...
self._sprites = Sprites(self._canvas)
self._dots = []
self._xo_man = None
self._generate_bg('#FFF')
# First dot, starting angle
self._cxy = [self._width / 2, self._height / 2]
self._xy = [
self._width / 2 + 120 * self._scale,
self._height / 2 - self._radius * self._scale
]
self._angle = 0
self._dot_size_plus = self._radius * 3 * self._scale
self._min = -self._dot_size_plus / 3
self._max = self._height - (self._dot_size_plus / 2.2)
self._zones = []
self._calc_zones()
self._generate_spiral()
def __init__(self, sprite_sheet_data):
Entity.__init__(self)
sprite_sheet = Sprites("tiles.png")
image = sprite_sheet.get_image(0, 0, 1, 1)
color_switch = image.get_at((0, 0))
self.image = sprite_sheet.get_image(sprite_sheet_data[0],
sprite_sheet_data[1],
sprite_sheet_data[2],
sprite_sheet_data[3])
self.image.set_colorkey(color_switch)
self.rect = self.image.get_rect()
def __init__(self):
pygame.sprite.Sprite.__init__(self)
sprites = Sprites("E:\Programming\Python\mygame\Xeonsheet.bmp")
#Right side sprites
image = sprites.get_image(17, 5, 45, 71)
color_switch = image.get_at((0, 0))
image.set_colorkey(color_switch)
self.walking_frames_r.append(image)
image = sprites.get_image(25, 170, 45, 71) #59,66
color_switch = image.get_at((2, 2))
image.set_colorkey(color_switch)
self.walking_frames_r.append(image)
image = sprites.get_image(103, 170, 45, 72) #59,66
color_switch = image.get_at((2, 2))
image.set_colorkey(color_switch)
self.walking_frames_r.append(image)
# Left side sprites
image = sprites.get_image(17, 5, 45, 72)
image.set_colorkey(color_switch)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprites.get_image(25, 170, 55, 71) # 59,66
color_switch = image.get_at((2, 2))
image.set_colorkey(color_switch)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprites.get_image(103, 170, 55, 72) # 59,66
color_switch = image.get_at((2, 2))
image.set_colorkey(color_switch)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
# Arxiko sprite
self.image = self.walking_frames_r[0]
self.rect = self.image.get_rect()
def __init__(self,
canvas,
parent=None,
path=None,
colors=['#A0FFA0', '#FF8080']):
self._canvas = canvas
self._parent = parent
self._parent.show_all()
self._path = path
self._colors = ['#FFFFFF']
self._colors.append(colors[0])
self._colors.append(colors[1])
self._canvas.connect('draw', self.__draw_cb)
self._width = Gdk.Screen.width()
self._height = Gdk.Screen.height() - (GRID_CELL_SIZE * 1.5)
self._scale = self._height / (3 * DOT_SIZE * 1.2)
self._scale /= 1.5
self._dot_size = int(DOT_SIZE * self._scale)
self._space = int(self._dot_size / 5.)
self.we_are_sharing = False
self._start_time = 0
self._timeout_id = None
# Find the image files
self._PATHS = glob.glob(os.path.join(self._path, 'images', '*.svg'))
# Generate the sprites we'll need...
self._sprites = Sprites(self._canvas)
self._dots = []
yoffset = self._space * 2 # int(self._space / 2.)
for y in range(3):
for x in range(3):
xoffset = int((self._width - 3 * self._dot_size - \
2 * self._space) / 2.)
self._dots.append(
Sprite(self._sprites,
xoffset + x * (self._dot_size + self._space),
y * (self._dot_size + self._space) + yoffset,
self._new_dot_surface(color=self._colors[0])))
self._dots[-1].type = -1 # No image
self._dots[-1].set_label_attributes(72)
def __init__(self, canvas, path, parent=None):
""" Initialize the playing surface """
self.path = path
self.activity = parent
# starting from command line
# we have to do all the work that was done in CardSortActivity.py
if parent is None:
self.sugar = False
self.canvas = canvas
# starting from Sugar
else:
self.sugar = True
self.canvas = canvas
parent.show_all()
self.canvas.set_flags(gtk.CAN_FOCUS)
self.canvas.add_events(gtk.gdk.BUTTON_PRESS_MASK)
self.canvas.add_events(gtk.gdk.BUTTON_RELEASE_MASK)
self.canvas.connect("expose-event", self._expose_cb)
self.canvas.connect("button-press-event", self._button_press_cb)
self.canvas.connect("button-release-event",
self._button_release_cb)
self.canvas.connect("key_press_event", self._keypress_cb)
self.width = gtk.gdk.screen_width()
self.height = gtk.gdk.screen_height() - GRID_CELL_SIZE
self.card_dim = CARD_DIM
self.scale = 0.6 * self.height / (self.card_dim * 3)
# Initialize the sprite repository
self.sprites = Sprites(self.canvas)
# Initialize the grid
self.mode = 'rectangle'
self.grid = Grid(self, self.mode)
self.bounds = LEVEL_BOUNDS[0]
self.level = 0
# Start solving the puzzle
self.press = None
self.release = None
self.start_drag = [0, 0]
def __init__(self, canvas, parent=None):
""" Initialize the canvas and set up the callbacks. """
self.activity = parent
if parent is None: # Starting from command line
self.sugar = False
self.canvas = canvas
else: # Starting from Sugar
self.sugar = True
self.canvas = canvas
parent.show_all()
self.canvas.set_flags(gtk.CAN_FOCUS)
self.canvas.add_events(gtk.gdk.BUTTON_PRESS_MASK)
self.canvas.add_events(gtk.gdk.BUTTON_RELEASE_MASK)
self.canvas.add_events(gtk.gdk.POINTER_MOTION_MASK)
self.canvas.connect("expose-event", self._expose_cb)
self.canvas.connect("button-press-event", self._button_press_cb)
self.canvas.connect("button-release-event", self._button_release_cb)
self.canvas.connect("motion-notify-event", self._mouse_move_cb)
self.width = gtk.gdk.screen_width()
self.height = gtk.gdk.screen_height()-GRID_CELL_SIZE
self.sprites = Sprites(self.canvas)
self.scale = gtk.gdk.screen_height()/900.0
self.dragpos = 0
self.press = None
self.chinese = Suanpan(self)
self.japanese = Soroban(self)
self.russian = Schety(self)
self.mayan = Nepohualtzintzin(self)
self.binary = Binary(self)
self.hex = Hex(self)
self.fraction = Fractions(self)
self.custom = None
self.chinese.show()
self.japanese.hide()
self.russian.hide()
self.mayan.hide()
self.binary.hide()
self.hex.hide()
self.fraction.hide()
self.mode = self.chinese
def inicializar_jogo(self):
self.ambiente = pygame
self.ambiente.init()
self.sprites = Sprites(pygame)
self.inputs = Inputs(self.ambiente)
self.clock_soldados_atiradores = self.ambiente.time.get_ticks()
self.clock_soldados_espada = self.ambiente.time.get_ticks()
self.clock_corvo = self.ambiente.time.get_ticks()
self.paused = False
self.cont_background = 0
self.width = 1280
self.height = 768
self.device_screen = self.ambiente.display.Info()
print(self.device_screen.current_w)
self.screen = self.ambiente.display.set_mode([self.width, self.height],
self.ambiente.FULLSCREEN
| self.ambiente.DOUBLEBUF)
self.background_imgs = [self.ambiente.image.load('imagens/mapa/mapa_1.png').convert(), self.ambiente.image.load('imagens/mapa/mapa_2.png').convert(),\
self.ambiente.image.load('imagens/mapa/mapa_3.png').convert(), self.ambiente.image.load('imagens/mapa/mapa_4.png').convert()]
self.background_image = self.background_imgs[0]
self.torre = self.ambiente.image.load(
'imagens/torre.png').convert_alpha()
self.indio = Indio(self.ambiente, 3, 1000, 0, 510)
self.cd = Cooldown(self.ambiente, 20, 490)
self.barra = Barra(self.ambiente, 10, 650)
self.lanca = Lanca(self.ambiente, 1, 0, 0, 20, 510, 0, 90)
self.barreira1 = Barreira(self.ambiente, 2, 400, 300, 'top')
self.barreira2 = Barreira(self.ambiente, 3, 400, 500, 'bot')
self.sprites.barreiras.add(self.barreira1, self.barreira2)
self.sprites.indio.add(self.indio)
self.sprites.todos_objetos.add(self.sprites.indio, self.barra,
self.sprites.barreiras)
self.clock_mapa = self.ambiente.time.get_ticks()
self.time = self.ambiente.time.get_ticks()
self.seta_menu = Seta(self.ambiente, 350, 200)
self.menu_background = self.ambiente.image.load(
'imagens/menu_background.png')
self.ambiente.font.init()
self.fonte = self.ambiente.font.SysFont('Comic Sans MS', 30)
self.screen.blit(self.background_image, [0, 0])
def __init__(self, canvas, path, parent=None):
self.activity = parent
self.path = path
# starting from command line
# we have to do all the work that was done in CardSortActivity.py
if parent is None:
self.sugar = False
self.canvas = canvas
# starting from Sugar
else:
self.sugar = True
self.canvas = canvas
parent.show_all()
self.canvas.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
self.canvas.add_events(Gdk.EventMask.BUTTON_RELEASE_MASK)
self.canvas.connect("draw", self.__draw_cb)
self.canvas.connect("button-press-event", self._button_press_cb)
self.canvas.connect("button-release-event", self._button_release_cb)
self.width = Gdk.Screen.width()
self.height = Gdk.Screen.height() - style.GRID_CELL_SIZE
self.height = Gdk.Screen.height() - style.GRID_CELL_SIZE
self.card_dim = CARD_DIM
self.scale = 0.8 * self.height / (self.card_dim * 3)
# Initialize the sprite repository
self.sprites = Sprites(self.canvas)
# Initialize the grid
self.grid = Grid(self)
# Start solving the puzzle
self.press = -1
self.release = -1
self.start_drag = [0, 0]
def new_window(canvas, path, parent=None):
sw = swWindow()
sw.path = path
sw.activity = parent
if parent is None:
sw.sugar = False
sw.canvas = canvas
else:
sw.sugar = True
sw.canvas = canvas
parent.show_all()
sw.canvas.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
sw.canvas.add_events(Gdk.EventMask.BUTTON_RELEASE_MASK)
sw.canvas.add_events(Gdk.EventMask.POINTER_MOTION_MASK)
sw.canvas.connect("draw", __draw_cb, sw)
sw.canvas.connect("button-press-event", _button_press_cb, sw)
sw.canvas.connect("button-release-event", _button_release_cb, sw)
sw.canvas.connect("motion-notify-event", _mouse_move_cb, sw)
sw.width = Gdk.Screen.width()
sw.height = Gdk.Screen.height()-GRID_CELL_SIZE
sw.sprites = Sprites(sw.canvas)
sw.sound = True
sw.scale = 2
sw.level = 1
sw.seq = gen_seq(40)
sw.counter = 0
sw.playpushed = False
# Open the buttons
d = W/4 # position fudge factor
# Esto hay que "custonearlo" :)
bs = str(random.randint(1,65))
gs = str(random.randint(1,65))
rs = str(random.randint(1,65))
ys = str(random.randint(1,65))
if bs == '58':
bs = str(random.randint(1,65))
if gs == '58':
gs = str(random.randint(1,65))
if rs == '58':
rs = str(random.randint(1,65))
if ys == '58':
ys = str(random.randint(1,65))
b = "Blue/"+bs
g = "Green/"+gs
r = "Red/"+rs
y = "Yellow/"+ys
bon = "Blue_On/"+bs
gon = "Green_On/"+gs
ron = "Red_On/"+rs
yon = "Yellow_On/"+ys
Remem = _("Remember")
sw.buttons_off = [Sprite(sw,b,sw.width/2-W/2,H/2-d,W/2,H/2),\
Sprite(sw,g,sw.width/2-W-d,H,W/2,H/2),\
Sprite(sw,r,sw.width/2+d,H,W/2,H/2),\
Sprite(sw,y,sw.width/2-W/2,H+H/2+d,W/2,H/2),\
Sprite(sw,Remem,0,610,600,290)]
sw.buttons_on = [Sprite(sw,bon,sw.width/2-W/2,H/2-d,W/2,H/2),\
Sprite(sw,gon,sw.width/2-W-d,H,W/2,H/2),\
Sprite(sw,ron,sw.width/2+d,H,W/2,H/2),\
Sprite(sw,yon,sw.width/2-W/2,H+H/2+d,W/2,H/2)]
Lista = [_('Blue'),_('Green'),_('Red'),_('Yellow')]
print Lista
sw.sounds = Lista
sw.sound_files = []
# Save sounds for repeated play
for i in sw.sounds:
playWave(i)
path = sw.activity.get_activity_root() + "/instance/" + i + ".csd"
sw.sound_files.append(path)
audioWrite(path)
_all_off(sw)
# Start calculating
sw.press = None
sw.dragpos = 0
return sw
def __init__(self, canvas, parent=None, path=None):
self._canvas = canvas
self._parent = parent
self._parent.show_all()
self._path = path
self._canvas.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
self._canvas.connect("draw", self.__draw_cb)
self._canvas.connect("button-press-event", self._button_press_cb)
self._width = Gdk.Screen.width()
self._height = Gdk.Screen.height()
self._scale = self._width / 1200.
self._target = 0
self._tries = 0
self.level = 0
self._picture_cards = []
self._small_picture_cards = []
self.food_cards = []
self._group_cards = []
self._quantity_cards = []
self._balance_cards = []
self._last_twenty = []
self._background = None
# Generate the sprites we'll need...
self._sprites = Sprites(self._canvas)
self._background = Sprite(
self._sprites, 0, 0,
GdkPixbuf.Pixbuf.new_from_file_at_size(
os.path.join(self._path, 'images', 'background.png'),
self._width, self._height))
self._background.set_layer(0)
self._background.type = None
self._background.hide()
self.pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size(
os.path.join(self._path, 'images', 'word-box.png'),
int(350 * self._scale), int(100 * self._scale))
for i in range(len(FOOD_DATA) / 4):
FOOD.append([
FOOD_DATA[i * 4 + NAME], FOOD_DATA[i * 4 + CALS],
FOOD_DATA[i * 4 + GROUP], FOOD_DATA[i * 4 + IMAGE]
])
self.food_cards.append(None)
self._picture_cards.append(None)
for j in range(6):
self._small_picture_cards.append(None)
self.allocate_food(0)
x = 10
dx, dy = self.food_cards[0].get_dimensions()
y = 10
for i in range(len(MYPLATE)):
self.word_card_append(self._group_cards, self.pixbuf)
self._group_cards[-1].type = i
self._group_cards[-1].set_label(MYPLATE[i][0])
self._group_cards[-1].move((x, y))
y += int(dy * 1.25)
y = 10
for i in range(len(QUANTITIES)):
self.word_card_append(self._quantity_cards, self.pixbuf)
self._quantity_cards[-1].type = i
self._quantity_cards[-1].set_label(QUANTITIES[i])
self._quantity_cards[-1].move((x, y))
y += int(dy * 1.25)
y = 10
for i in range(len(BALANCE)):
self.word_card_append(self._balance_cards, self.pixbuf)
self._balance_cards[-1].type = i
self._balance_cards[-1].set_label(BALANCE[i])
self._balance_cards[-1].move((x, y))
y += int(dy * 1.25)
self._smile = Sprite(
self._sprites, int(self._width / 4), int(self._height / 4),
GdkPixbuf.Pixbuf.new_from_file_at_size(
os.path.join(self._path, 'images', 'correct.png'),
int(self._width / 2), int(self._height / 2)))
self._smile.set_label_attributes(36)
self._smile.set_margins(10, 0, 10, 0)
self._frown = Sprite(
self._sprites, int(self._width / 4), int(self._height / 4),
GdkPixbuf.Pixbuf.new_from_file_at_size(
os.path.join(self._path, 'images', 'wrong.png'),
int(self._width / 2), int(self._height / 2)))
self._frown.set_label_attributes(36)
self._frown.set_margins(10, 0, 10, 0)
self.build_food_groups()
self._all_clear()
def new_window(canvas, path, parent=None):
sw = swWindow()
sw.path = path
sw.activity = parent
# starting from command line
# we have to do all the work that was done in CardSortActivity.py
if parent is None:
sw.sugar = False
sw.canvas = canvas
# starting from Sugar
else:
sw.sugar = True
sw.canvas = canvas
parent.show_all()
sw.canvas.set_flags(gtk.CAN_FOCUS)
sw.canvas.add_events(gtk.gdk.BUTTON_PRESS_MASK)
sw.canvas.add_events(gtk.gdk.BUTTON_RELEASE_MASK)
sw.canvas.add_events(gtk.gdk.POINTER_MOTION_MASK)
sw.canvas.connect("expose-event", _expose_cb, sw)
sw.canvas.connect("button-press-event", _button_press_cb, sw)
sw.canvas.connect("button-release-event", _button_release_cb, sw)
sw.canvas.connect("motion-notify-event", _mouse_move_cb, sw)
sw.width = gtk.gdk.screen_width()
sw.height = gtk.gdk.screen_height() - GRID_CELL_SIZE
sw.sprites = Sprites(sw.canvas)
sw.sound = True
sw.scale = 2
sw.level = 1
sw.seq = gen_seq(40)
sw.counter = 0
sw.playpushed = False
# Open the buttons
d = W / 4 # position fudge factor
sw.buttons_off = [Sprite(sw,"Aoff",sw.width/2-W/2,H/2-d,W/2,H/2),\
Sprite(sw,"Boff",sw.width/2-W-d,H,W/2,H/2),\
Sprite(sw,"Doff",sw.width/2+d,H,W/2,H/2),\
Sprite(sw,"Coff",sw.width/2-W/2,H+H/2+d,W/2,H/2)]
sw.buttons_on = [Sprite(sw,"Aon",sw.width/2-W/2,H/2-d,W/2,H/2),\
Sprite(sw,"Bon",sw.width/2-W-d,H,W/2,H/2),\
Sprite(sw,"Don",sw.width/2+d,H,W/2,H/2),\
Sprite(sw,"Con",sw.width/2-W/2,H+H/2+d,W/2,H/2)]
sw.sounds = ['dog', 'sheep', 'cat', 'bird']
sw.sound_files = []
# Save sounds for repeated play
for i in sw.sounds:
playWave(i)
path = sw.activity.get_activity_root() + "/instance/" + i + ".csd"
sw.sound_files.append(path)
audioWrite(path)
_all_off(sw)
# Start calculating
sw.press = None
sw.dragpos = 0
return sw
def _setup_workspace(self):
''' Prepare to render the datastore entries. '''
self._colors = profile.get_color().to_string().split(',')
# Use the lighter color for the text background
if lighter_color(self._colors) == 0:
tmp = self._colors[0]
self._colors[0] = self._colors[1]
self._colors[1] = tmp
self._width = gtk.gdk.screen_width()
self._height = gtk.gdk.screen_height()
self._scale = gtk.gdk.screen_height() / 900.
if self._hw[0:2] == 'xo':
titlef = 18
descriptionf = 12
else:
titlef = 36
descriptionf = 24
# Generate the sprites we'll need...
self._sprites = Sprites(self._canvas)
self._title = Sprite(
self._sprites, 0, 0,
svg_str_to_pixbuf(
genblank(self._width, int(TITLEH * self._scale),
self._colors)))
self._title.set_label_attributes(int(titlef * self._scale),
rescale=False)
self._preview = Sprite(
self._sprites, int(
(self._width - int(PREVIEWW * self._scale)) / 2),
int(PREVIEWY * self._scale),
svg_str_to_pixbuf(
genblank(int(PREVIEWW * self._scale),
int(PREVIEWH * self._scale), self._colors)))
self._full_screen = Sprite(
self._sprites, int((self._width - int(FULLW * self._scale)) / 2),
int(PREVIEWY * self._scale),
svg_str_to_pixbuf(
genblank(int(FULLW * self._scale), int(FULLH * self._scale),
self._colors)))
self._description = Sprite(
self._sprites, int(DESCRIPTIONX * self._scale),
int(DESCRIPTIONY * self._scale),
svg_str_to_pixbuf(
genblank(int(self._width - (2 * DESCRIPTIONX * self._scale)),
int(DESCRIPTIONH * self._scale), self._colors)))
self._description.set_label_attributes(int(descriptionf * self._scale))
self._description2 = Sprite(
self._sprites, int(SHORTX * self._scale),
int(SHORTY * self._scale),
svg_str_to_pixbuf(
genblank(int(self._width - (2 * SHORTX * self._scale)),
int(SHORTH * self._scale), self._colors)))
self._description2.set_label_attributes(int(descriptionf *
self._scale))
self._my_canvas = Sprite(
self._sprites, 0, 0,
gtk.gdk.Pixmap(self._canvas.window, self._width, self._height, -1))
self._my_gc = self._my_canvas.images[0].new_gc()
self._my_canvas.set_layer(BOTTOM)
self._clear_screen()
self._find_starred()
self.i = 0
self._show_slide()
self._playing = False
self._rate = 10
def __init__(self, canvas, parent=None, colors=['#A0FFA0', '#FF8080']):
self._activity = parent
self._colors = ['#FFFFFF']
self._colors.append(colors[0])
self._colors.append(colors[1])
self._colors.append('#000000')
self._canvas = canvas
if parent is not None:
parent.show_all()
self._parent = parent
self._canvas.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
self._canvas.connect("draw", self.__draw_cb)
self._canvas.connect("button-press-event", self._button_press_cb)
self._width = Gdk.Screen.width()
self._height = Gdk.Screen.height() - (GRID_CELL_SIZE * 1.5)
self._scale = self._width / (20 * DOT_SIZE * 1.1)
self._dot_size = int(DOT_SIZE * self._scale)
self._space = int(self._dot_size / 5.)
self.we_are_sharing = False
self._sum = 0
self._mode = 'ten'
self.custom = [1, 1, 1, 1, 10]
# Generate the sprites we'll need...
self._sprites = Sprites(self._canvas)
Sprite(self._sprites, 0, 0,
self._box(self._width, self._height, color=colors[1]))
self._number_box = Sprite(
self._sprites, 0, 0,
self._box(self._width, 2 * self._dot_size, color=colors[1]))
self._number_box.set_label_attributes(48)
self._dots = []
for p in range(SIX):
y = self._height - self._space
Sprite(self._sprites, 0, y, self._line(vertical=False))
x = int(p * self._width / 6) + self._space
y -= self._dot_size
for d in range(3): # bottom of fives row
self._dots.append(
Sprite(self._sprites, x, y,
self._new_dot(self._colors[0])))
self._dots[-1].type = 0 # not set
# self._dots[-1].set_label_color('white')
x += self._dot_size + self._space
x = int((p * self._width / 6.) + self._dot_size / 2.) + self._space
y -= self._dot_size + self._space
for d in range(2): # top of fives row
self._dots.append(
Sprite(self._sprites, x, y,
self._new_dot(self._colors[0])))
self._dots[-1].type = 0 # not set
# self._dots[-1].set_label_color('white')
x += self._dot_size + self._space
y -= self._dot_size
Sprite(self._sprites, 0, y, self._line(vertical=False))
x = int((p * self._width / 6.) + self._dot_size / 2.) + self._space
y -= self._dot_size
for d in range(2): # bottom of threes row
self._dots.append(
Sprite(self._sprites, x, y,
self._new_dot(self._colors[0])))
self._dots[-1].type = 0 # not set
# self._dots[-1].set_label_color('white')
x += self._dot_size + self._space
x = int((p * self._width / 6.) + self._dot_size) + self._space
y -= self._dot_size + self._space
for d in range(1): # top of threes row
self._dots.append(
Sprite(self._sprites, x, y,
self._new_dot(self._colors[0])))
self._dots[-1].type = 0 # not set
# self._dots[-1].set_label_color('white')
x += self._dot_size + self._space
y -= self._dot_size
Sprite(self._sprites, 0, y, self._line(vertical=False))
x = int((p * self._width / 6.) + self._dot_size / 2.) + self._space
y -= self._dot_size
for d in range(2): # twos row
self._dots.append(
Sprite(self._sprites, x, y,
self._new_dot(self._colors[0])))
self._dots[-1].type = 0 # not set
# self._dots[-1].set_label_color('white')
x += self._dot_size + self._space
y -= self._dot_size
Sprite(self._sprites, 0, y, self._line(vertical=False))
x = int((p * self._width / 6.) + self._dot_size) + self._space
y -= self._dot_size
for d in range(1): # ones row
self._dots.append(
Sprite(self._sprites, x, y,
self._new_dot(self._colors[0])))
self._dots[-1].type = 0 # not set
# self._dots[-1].set_label_color('white')
x += self._dot_size + self._space
y -= self._dot_size
Sprite(self._sprites, 0, y, self._line(vertical=False))
for p in range(SIX - 1):
x = int((p + 1) * self._width / 6)
Sprite(self._sprites, x - 1, y, self._line(vertical=True))
# and initialize a few variables we'll need.
self._all_clear()
def run_game():
# Create the pygame module.
pygame.init()
# Get the pygame clock.
pygame_clock = pygame.time.Clock()
# Initialize the random seed.
random.seed()
# Create the game settings.
ai_settings = Settings()
# The backbuffer of the game.
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Space Invaders")
# Make the sprite loader object.
sprites = Sprites()
# Create an instance to store game statistics.
stats = GameStats(ai_settings)
# Create the scoreboard.
sb = Scoreboard(ai_settings, screen, stats, sprites)
# Checks if the game is currently running.
game_running = True
# Make a group to store bullets in.
bullets = Group()
# Make a group to store enemy bullets in.
enemy_bullets = Group()
# Make a group to store the aliens in.
aliens = Group()
# Make a group to store the barriers in.
barriers = Group()
# Make the Space text.
space_text = None
# Make the Invaders text.
invaders_text = None
# Make the high scores text.
high_scores_text = None
while game_running:
if ai_settings.current_sequence == 0:
# Make the Play button.
if ai_settings.play_button is None:
ai_settings.play_button = Button(ai_settings, screen, 600, (128, 255, 128), "PLAY GAME")
# Make the Play button.
if ai_settings.high_scores_button is None:
ai_settings.high_scores_button = Button(ai_settings, screen, 664, (128, 128, 128), "HIGH SCORES")
# Make the Space text.
if space_text is None:
cur_font = pygame.font.Font("fonts/BPdotsPlusBold.otf", 128)
# Build the button's rect object and center it.
space_text = cur_font.render("SPACE", True, (255, 255, 255), (0, 0, 0))
# Make the Invaders text.
if invaders_text is None:
cur_font = pygame.font.Font("fonts/BPdotsPlusBold.otf", 64)
# Build the button's rect object and center it.
invaders_text = cur_font.render("INVADERS", True, (128, 255, 128), (0, 0, 0))
elif ai_settings.current_sequence == 1:
if ai_settings.ship is None:
# Make a ship
ai_settings.ship = Ship(screen, ai_settings, sprites)
ai_settings.ship.center_ship()
if stats.game_active and game_running:
# Updating the game objects.
ai_settings.ship.update()
# Check if the level needs to be ended.
if ai_settings.end_level:
gf.end_level(ai_settings, screen, stats, sb, aliens, bullets, enemy_bullets,
barriers, sprites)
if not ai_settings.ship_destroyed and ai_settings.ship is not None:
gf.update_bullets(ai_settings, screen, stats, sb, aliens, bullets,
enemy_bullets, barriers, sprites)
gf.update_enemy_bullets(ai_settings, screen, stats, sb, aliens, bullets,
enemy_bullets, barriers, sprites)
gf.update_aliens(ai_settings, screen, stats, sb, aliens, bullets,
enemy_bullets, barriers, sprites)
elif ai_settings.current_sequence == 3:
# Make the Invaders text.
if high_scores_text is None:
cur_font = pygame.font.Font("fonts/BPdotsPlusBold.otf", 64)
# Build the button's rect object and center it.
high_scores_text = cur_font.render("HIGH SCORES", True, (128, 255, 128), (0, 0, 0))
# Make the high scores back button.
if ai_settings.high_scores_back_button is None:
ai_settings.high_scores_back_button = Button(ai_settings, screen, 664, (128, 128, 128), "BACK")
# Updating the rendering process.
gf.update_screen(ai_settings, screen, stats, sb, aliens, bullets,
enemy_bullets, barriers, space_text, invaders_text, high_scores_text, sprites)
# Checking for game events.
game_running = gf.check_events(game_running, stats, sb, ai_settings, screen, aliens, bullets,
enemy_bullets, barriers, sprites)
pygame_clock.tick(60)
# Exit pygame.
pygame.quit()
# Quit the program.
sys.exit()
def __init__(self,
canvas,
parent=None,
path=None,
colors=['#A0FFA0', '#FF8080']):
self._canvas = canvas
self._parent = parent
self._parent.show_all()
self._path = path
self._colors = ['#FFFFFF']
self._colors.append(colors[0])
self._colors.append(colors[1])
self._canvas.set_can_focus(True)
self._canvas.connect("draw", self._draw_cb)
self._canvas.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
self._canvas.connect("button-press-event", self._button_press_cb)
self._width = Gdk.Screen.width()
self._height = Gdk.Screen.height() - (GRID_CELL_SIZE * 1.5)
self._scale = self._height / (4 * DOT_SIZE * 1.3)
self._dot_size = int(DOT_SIZE * self._scale)
self._space = int(self._dot_size / 5.)
self.we_are_sharing = False
self._start_time = 0
self._timeout_id = None
self._level = 3
self._game = 0
self._correct = 0
# Find the image files
self._PATHS = glob(os.path.join(self._path, 'images'), '.png')
self._CPATHS = glob(os.path.join(self._path, 'color-images'), '*.svg')
# Generate the sprites we'll need...
self._sprites = Sprites(self._canvas)
self._dots = []
self._opts = []
yoffset = int(self._space / 2.)
self._line = Sprite(
self._sprites, 0,
int(3 * (self._dot_size + self._space) + yoffset / 2.),
self._line(vertical=False))
for y in range(3):
for x in range(6):
xoffset = int((self._width - 6 * self._dot_size - \
5 * self._space) / 2.)
self._dots.append(
Sprite(self._sprites,
xoffset + x * (self._dot_size + self._space),
y * (self._dot_size + self._space) + yoffset,
self._new_dot_surface(color=self._colors[0])))
self._dots[-1].type = -1 # No image
self._dots[-1].set_label_attributes(72)
y = 3
for x in range(3):
self._opts.append(
Sprite(self._sprites,
xoffset + x * (self._dot_size + self._space),
y * (self._dot_size + self._space) + yoffset,
self._new_dot_surface(color=self._colors[0])))
self._opts[-1].type = -1 # No image
self._opts[-1].set_label_attributes(72)
self._opts[-1].hide()
