def __init__(self, game):
self.grid = [0, 1, 2, 3, 4, 5, 6, 7, 8]
self.card_table = []
self.mask_table = []
# Stuff to keep around for the graphics
self.w = int(game.width)
self.h = int(game.height)
self.d = int(game.card_dim * game.scale)
self.s = game.scale
# Initialize the cards
i = 0 # i is used as a label on the sprite
for c in CARD_DEFS:
x, y = self.i_to_xy(i)
self.card_table.append(Card(game, c, i, x, y))
i += 1
# Initialize the masks (We need up to 6 of each one.)
for i in range(4):
bitmap = load_image(os.path.join(game.path, 'mask%dh.svg' % (i)),
120 * game.scale, 48 * game.scale)
for j in range(6):
x, y = self.mh_to_xy(j)
self.mask_table.append(Sprite(game.sprites, x, y, bitmap))
bitmap = load_image(os.path.join(game.path, 'mask%dv.svg' % (i)),
48 * game.scale, 120 * game.scale)
for j in range(6):
x, y = self.mv_to_xy(j)
self.mask_table.append(Sprite(game.sprites, x, y, bitmap))
self.hide_masks()
def _create_number_sprites(self):
for i in range(5):
self._numbers.append([])
self._glownumbers.append([])
for j in range(5):
if self.i == 0:
x = self.sx(
NX[self.i]) + i * (self.ss(NS[self.i] + NO[self.i]))
y = self.sy(NY[self.i])
else:
x = self.sx(NX[self.i])
y = self.sy(
NY[self.i]) + i * (self.ss(NS[self.i] + NO[self.i]))
number = Sprite(
self._sprites, x, y,
self._parent.number_pixbuf(self.ss(NS[self.i]), j + 1,
self._parent.sugarcolors[1]))
number.type = 'number'
number.name = '%d,%d' % (i, j)
self._numbers[i].append(number)
number = Sprite(
self._sprites, x, y,
self._parent.number_pixbuf(self.ss(NS[self.i]), j + 1,
'#FFFFFF'))
number.type = 'number'
number.name = '%d,%d' % (i, j)
self._glownumbers[i].append(number)
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,
sprites,
path,
name,
x,
y,
w,
h,
svg_engine=None,
function=None):
if svg_engine is None:
self.spr = Sprite(sprites, x, y, file_to_pixbuf(path, name, w, h))
else:
self.spr = Sprite(sprites, x, y,
svg_str_to_pixbuf(svg_engine().svg))
self.tab_dx = [0, SWIDTH - TABWIDTH]
self.tab_dy = [2 * SHEIGHT, 2 * SHEIGHT]
self.tabs = []
self.tabs.append(
Tab(sprites, path, 'tab', x + self.tab_dx[0], y + self.tab_dy[0],
TABWIDTH, SHEIGHT))
self.tabs.append(
Tab(sprites, path, 'tab', x + self.tab_dx[1], y + self.tab_dy[1],
TABWIDTH, SHEIGHT))
self.calculate = function
self.name = name
def create(self, string, attributes=None, sprites=None, file_path=None):
if attributes is None:
if self.spr is None:
self.spr = Sprite(sprites, 0, 0, svg_str_to_pixbuf(string))
else:
self.spr.set_image(svg_str_to_pixbuf(string))
self.index = None
else:
self.shape = attributes[0]
self.color = attributes[1]
self.num = attributes[2]
self.fill = attributes[3]
self.index = self.shape * COLORS * NUMBER * FILLS + \
self.color * NUMBER * FILLS + \
self.num * FILLS + \
self.fill
if self.spr is None:
self.spr = Sprite(sprites, 0, 0, svg_str_to_pixbuf(string))
else:
self.spr.set_image(svg_str_to_pixbuf(string))
if file_path is not None:
self.spr.set_image(load_image(file_path, self._scale),
i=1,
dx=int(self._scale * CARD_WIDTH * .125),
dy=int(self._scale * CARD_HEIGHT * .125))
self.spr.set_label_attributes(self._scale * 24)
self.spr.set_label('')
def __init__(self, cards):
self.frame = Sprite(
0,
c.sizes["topmenu"][1],
image=pygame.image.load(
"assets/misc/chooseYourPlants.png").convert_alpha(),
size=c.sizes["choose"])
self.button_images = list(
map(lambda i: pygame.transform.smoothscale(i, c.sizes["letsRock"]),
[
pygame.image.load(
"assets/misc/letsRock.png").convert_alpha(),
pygame.image.load(
"assets/misc/letsRockHighlight.png").convert_alpha()
]))
self.button = Sprite(158, 568, image=self.button_images[0])
self.cards = pygame.sprite.Group()
self.x = c.pads["choose"][0]
self.starting_x = self.x
y = c.pads["choose"][1]
_c = 0
for card in cards:
_c += 1
image = pygame.image.load(
f"assets/cards/card{card.__name__}.png").convert()
s = Card(self.x, card, image=image, size=c.sizes["card"], y=y)
self.cards.add(s)
self.x += c.sizes["card"][0] + 2
if _c % 7 == 0:
self.x = self.starting_x
y += c.sizes["card"][1] + 5
def word_card_append(self, card_list, pixbuf, i=-1):
if i == -1:
card_list.append(Sprite(self._sprites, 10, 10, pixbuf))
else:
card_list[i] = Sprite(self._sprites, 10, 10, pixbuf)
card_list[i].set_label_attributes(36)
card_list[i].set_margins(10, 0, 10, 0)
card_list[i].hide()
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 draw_rods_and_beads(self, x, y):
""" Draw the rods and beads """
_white = _svg_header(BWIDTH, BHEIGHT, self.abacus.scale) +\
_svg_bead("#ffffff", "#000000") +\
_svg_footer()
_yellow1 = _svg_header(BWIDTH, BHEIGHT, self.abacus.scale) +\
_svg_bead("#ffffcc", "#000000") +\
_svg_footer()
_yellow2 = _svg_header(BWIDTH, BHEIGHT, self.abacus.scale) +\
_svg_bead("#ffff88", "#000000") +\
_svg_footer()
_yellow3 = _svg_header(BWIDTH, BHEIGHT, self.abacus.scale) +\
_svg_bead("#ffff00", "#000000") +\
_svg_footer()
self.colors = [_svg_str_to_pixbuf(_white),
_svg_str_to_pixbuf(_yellow1),
_svg_str_to_pixbuf(_yellow2),
_svg_str_to_pixbuf(_yellow3)]
dx = (BWIDTH+BOFFSET)*self.abacus.scale
bo = (BWIDTH-BOFFSET)*self.abacus.scale/4
ro = (BWIDTH+5)*self.abacus.scale/2
for i in range(self.num_rods):
_rod = _svg_header(10, self.frame_height-(FSTROKE*2),
self.abacus.scale) +\
_svg_rect(10, self.frame_height-(FSTROKE*2), 0, 0, 0, 0,
ROD_COLORS[i%len(ROD_COLORS)], "#404040") +\
_svg_footer()
self.rods.append(Sprite(self.abacus.sprites, x+i*dx+ro, y,
_svg_str_to_pixbuf(_rod)))
for b in range(self.top_beads):
self.beads.append(Bead(Sprite(self.abacus.sprites, x+i*dx+bo,
y+b*BHEIGHT*self.abacus.scale,
self.colors[0]),
2*BHEIGHT*self.abacus.scale,
self.top_factor*(pow(self.base,
self.num_rods-i-1))))
for b in range(self.bot_beads):
if self.top_beads > 0:
self.beads.append(Bead(Sprite(self.abacus.sprites,
x+i*dx+bo,
y+(self.top_beads+5+b)*\
BHEIGHT*self.abacus.scale,
self.colors[0]),
2*BHEIGHT*self.abacus.scale,
pow(self.base,self.num_rods-i-1)))
else:
self.beads.append(Bead(Sprite(self.abacus.sprites,
x+i*dx+bo,
y+(2+b)*BHEIGHT\
*self.abacus.scale,
self.colors[0]),
2*BHEIGHT*self.abacus.scale,
pow(self.base,self.num_rods-i-1)))
for rod in self.rods:
rod.type = "frame"
def _create_results_sprites(self):
x = 0
y = self.sy(GY[self.i])
self._success = Sprite(self._sprites, x, y,
self._parent.good_job_pixbuf())
self._success.hide()
self._failure = Sprite(self._sprites, x, y,
self._parent.try_again_pixbuf())
self._failure.hide()
def highlight_graphic(sprites, scale=1.0):
return [
Sprite(sprites, -100, 0,
svg_str_to_pixbuf(generate_corners(0, 0.125 * scale))),
Sprite(sprites, -100, 0,
svg_str_to_pixbuf(generate_corners(1, 0.125 * scale))),
Sprite(sprites, -100, 0,
svg_str_to_pixbuf(generate_corners(2, 0.125 * scale))),
Sprite(sprites, -100, 0,
svg_str_to_pixbuf(generate_corners(3, 0.125 * scale)))
]
def __init__(self, username, size=(1200,800)):
pygame.init()
self.size = size
self.screen = pygame.display.set_mode(size )
pygame.display.set_caption("GrandTheftSchema2")
pygame.mouse.set_visible(1)
pygame.key.set_repeat(1, 1)
self.renderitems=[]
self.renderimages=[]
self.renderlock = threading.Semaphore()
self.clock = pygame.time.Clock()
self.userpos = None
self.username = username
self.CACHEMODE = False
self.font = pygame.font.Font("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 12)
self.querybg = Sprite('images/querybg.png',(800,200), True)
self.forkme = Sprite('images/forkme.png',(298,298), True)
self.GTS_OVERVIEW = Sprite('images/GTS_OVERVIEW.png',self.size, False)
self._overviewmap = None
self._overviewboundslower=None
self._overviewboundsupper=None
self._overviewsize=None
self.lastactivity = time.time()
self.kreis = Sprite('images/kreis.png',(20,20), True)
self.activelogo = Sprite('images/phant.png',(20,20), True)
self.activelogo.xpos=0
#rasterm = rastermap.rastermap()
self.rastermap = rastermap.rastermap()
self.envpool = []
for x in range(0,multiprocessing.cpu_count()-1):
a = environmenter(self.rastermap)
self.envpool.append( a )
a.start()
self.initBoundingBox()
self.objectmanager = objectmanager()
self.objectpuller = objectpuller(None,self.objectmanager, username )
self.objectpuller.start()
self.rastermap.setZoom(1)
self.ticker=ticker()
self.ticker.start()
self.lastcontrolledobject = None
def make_labels(self):
''' Label the bar '''
num = svg_header(BAR_HEIGHT * self.scale, BAR_HEIGHT * self.scale,
1.0) + \
svg_rect(BAR_HEIGHT * self.scale, BAR_HEIGHT * self.scale,
0, 0, 0, 0, 'none', 'none') + \
svg_footer()
self.left = Sprite(self.sprites, int(self.ball_size / 4), self.bar_y(),
svg_str_to_pixbuf(num))
self.left.set_label(_('0'))
self.right = Sprite(self.sprites,
self.screen_width - int(self.ball_size / 2),
self.bar_y(), svg_str_to_pixbuf(num))
self.right.set_label(_('1'))
def _generate_grid(self):
''' Make a new set of dots for a grid of size edge '''
i = 0
for y in range(self._edge):
for x in range(self._edge):
xoffset = int((self._width - self._edge * self._dot_size -
(self._edge - 1) * self._space) / 2.)
yoffset = int((self._height - self._edge * self._dot_size -
(self._edge - 1) * self._space) / 2.)
if i < len(self._dots):
self._dots[i].move(
(xoffset + x * (self._dot_size + self._space),
yoffset + y * (self._dot_size + self._space)))
else:
self._dots.append(
Sprite(self._sprites,
xoffset + x * (self._dot_size + self._space),
yoffset + y * (self._dot_size + self._space),
self._new_dot(self._colors[0])))
self._dots[i].type = 0
self._dots[-1].set_label_attributes(40)
i += 1
# and initialize a few variables we'll need.
self._all_clear()
def __init__(self, cards: list = None, pos: int = 100):
if cards is None:
cards = []
# TODO добавить остальные цифры
# Digits for sun display
self.digits = {
str(n): pygame.image.load(f"assets/misc/{n}.png").convert_alpha()
for n in range(10)
}
# Main frame
self.frame = Sprite(
pos,
0,
image=pygame.image.load("assets/misc/topmenu.png").convert_alpha(),
size=c.sizes["topmenu"])
# Positions cards
self.cards = pygame.sprite.Group()
self.x = c.pads["sun"][0] + (c.pads["menubar"][0]
if self.get_preparing() else 0)
self.starting_x = self.x
for card in cards:
image = pygame.image.load(
f"assets/cards/card{card.__name__}.png").convert()
s = Card(self.x, card, image=image, size=c.sizes["card"])
self.cards.add(s)
self.x += c.sizes["card"][0] + c.pads["cards"]
self.shovel = Shovel(c.sizes["topmenu"][0] + c.pads["menubar"][0], 0)
def _generate_spiral(self):
''' Make a new set of dots for a sprial '''
for z in range(4):
for i in range(len(colors)):
if self._zones[i] == z:
self._dots.append(
Sprite(self._sprites, self._xy[0], self._xy[1],
self._new_dot(colors[i])))
self._dots[-1].type = i
self._calc_next_dot_position()
if self._xo_man is None:
x = 510 * self._scale
y = 280 * self._scale
self._xo_man = Sprite(self._sprites, x, y,
self._new_xo_man(self.colors))
self._xo_man.type = None
def create_toolbar_background(sprite_list, width):
# Create the toolbar background for the selectors
spr = Sprite(sprite_list, 0, 0,
svg_str_to_pixbuf(SVG().toolbar(2 * width, ICON_SIZE)))
spr.type = 'toolbar'
spr.set_layer(CATEGORY_LAYER)
return spr
def _make_wedge_bar(self, nsegments):
''' Create a wedged-shaped bar with n segments '''
s = 3.5 # add provision for stroke width
svg = svg_header(self._width, BAR_HEIGHT * self._scale + s, 1.0)
dx = self._width / float(nsegments)
dy = (BAR_HEIGHT * self._scale) / float(nsegments)
for i in range(int(nsegments) // 2):
svg += svg_wedge(dx, BAR_HEIGHT * self._scale + s,
i * 2 * dx + s,
i * 2 * dy + s, (i * 2 + 1) * dy + s,
'#000000', '#FFFFFF')
svg += svg_wedge(dx, BAR_HEIGHT * self._scale + s,
(i * 2 + 1) * dx + s,
(i * 2 + 1) * dy + s, (i * 2 + 2) * dy + s,
'#000000', '#FFFFFF')
if int(nsegments) % 2 == 1: # odd
svg += svg_wedge(dx, BAR_HEIGHT * self._scale + s,
(i * 2 + 2) * dx + s,
(i * 2 + 2) * dy + s,
BAR_HEIGHT * self._scale + s,
'#000000', '#FFFFFF')
svg += svg_footer()
self.bars[nsegments] = Sprite(self._sprites, 0, 0,
svg_str_to_pixbuf(svg))
self.bars[nsegments].set_layer(2)
self.bars[nsegments].set_label_attributes(18, horiz_align="left", i=0)
self.bars[nsegments].set_label_attributes(18, horiz_align="right", i=1)
self.bars[nsegments].set_label_color('black', i=0)
self.bars[nsegments].set_label_color('white', i=1)
self.bars[nsegments].set_label(' 0', i=0)
self.bars[nsegments].set_label('1 ', i=1)
self.bars[nsegments].move(
(0, self._height - BAR_HEIGHT * self._scale))
def _make_background(self, x, y, w, h, regenerate=False):
''' Make the background sprite for the palette. '''
orientation = self._turtle_window.orientation
if regenerate and not self.backgrounds[orientation] is None:
self.backgrounds[orientation].hide()
self.backgrounds[orientation] = None
if self.backgrounds[orientation] is None:
svg = SVG()
self.backgrounds[orientation] = \
Sprite(self._turtle_window.sprite_list, x, y,
svg_str_to_pixbuf(svg.palette(w, h)))
self.backgrounds[orientation].save_xy = (x, y)
self._float_palette(self.backgrounds[orientation])
if orientation == 0 and w > self._turtle_window.width:
self.backgrounds[orientation].type = \
'category-shift-horizontal'
elif orientation == 1 and \
h > self._turtle_window.height - ICON_SIZE:
self.backgrounds[orientation].type = \
'category-shift-vertical'
else:
self.backgrounds[orientation].type = 'category'
'''
def __init__(self, parent):
super().__init__(parent)
# Location music
pygame.mixer_music.load("assets/audio/chooseYourSeeds.mp3")
pygame.mixer_music.play(loops=-1)
self.bg = Sprite(
0, 0, image=pygame.image.load("assets/misc/bg.png").convert())
# At the begging camera moves to the right side of background
self.move_times = (self.bg.image.get_width() - c.sizes["win"][0]) / 5
# Card choices
self.plant_choice_widget = PlantChoiceMenu( # Contains all working plants
[
PotatoMine, Sunflower, SnowPea, CherryBomb, Chomper, Repeater,
WallNut, PeaShooter
])
# Menu which usually displays suns and chosen cards
# New cards added here
self.top_menu = TopMenu(pos=0)
# Sounds and images for pre-game state
self.ready_set_plant = pygame.mixer.Sound(
"assets/audio/readysetplant.wav")
self.ready_set_plant_images = [
pygame.image.load("assets/misc/StartReady.png").convert_alpha(),
pygame.image.load("assets/misc/StartSet.png").convert_alpha(),
pygame.image.load("assets/misc/StartPlant.png").convert_alpha(),
]
self.counter = 0
def configure_cb(self, event):
self._width = Gdk.Screen.width()
self._height = Gdk.Screen.height() - GRID_CELL_SIZE
self._scale = Gdk.Screen.height() / 900.0
# We need to resize the backgrounds
width, height = self._calc_background_size()
for bg in list(self._backgrounds.keys()):
if bg == 'custom':
path = self._custom_dsobject.file_path
pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size(
path, width, height)
else:
pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size(
os.path.join(self._path, 'images', bg), width, height)
if Gdk.Screen.height() > Gdk.Screen.width():
pixbuf = self._crop_to_portrait(pixbuf)
self._backgrounds[bg] = pixbuf
self._background = Sprite(self._sprites, 0, 0,
self._backgrounds[self._current_bg])
self._background.set_layer(-100)
self._background.type = 'background'
# and resize and reposition the bars
self.bar.resize_all()
self.bar.show_bar(2)
self._current_bar = self.bar.get_bar(2)
# Calculate a new accerlation based on screen height.
self._ddy = (6.67 * self._height) / (STEPS * STEPS)
self._guess_orientation()
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 draw_rods_and_beads(self, x, y):
""" Override default in order to make a short rod """
_white = _svg_header(BWIDTH, BHEIGHT, self.abacus.scale) +\
_svg_bead("#ffffff", "#000000") +\
_svg_footer()
self.white = _svg_str_to_pixbuf(_white)
_black = _svg_header(BWIDTH, BHEIGHT, self.abacus.scale) +\
_svg_bead("#000000", "#000000") +\
_svg_footer()
self.black = _svg_str_to_pixbuf(_black)
dx = (BWIDTH+BOFFSET)*self.abacus.scale
self.beads = []
self.rods = []
bo = (BWIDTH-BOFFSET)*self.abacus.scale/4
ro = (BWIDTH+5)*self.abacus.scale/2
for i in range(self.num_rods):
_rod = _svg_header(10, self.frame_height-(FSTROKE*2),
self.abacus.scale) +\
_svg_rect(10, self.frame_height-(FSTROKE*2), 0, 0, 0, 0,
ROD_COLORS[(i+9)%len(ROD_COLORS)], "#404040") +\
_svg_footer()
self.rods.append(Sprite(self.abacus.sprites, x+i*dx+ro, y,
_svg_str_to_pixbuf(_rod)))
for b in range(self.bead_count[i]):
if i < 6: # whole-number beads are white
self.beads.append(Bead(Sprite(self.abacus.sprites,
x+i*dx+bo,
y+(14-self.bead_count[i]+b)*\
BHEIGHT*self.abacus.scale,
self.white),
4*BHEIGHT*self.abacus.scale,
pow(10,5-i)))
else: # fraction beads are black
self.beads.append(Bead(Sprite(self.abacus.sprites,
x+i*dx+bo,
y+(14-self.bead_count[i]+b)*\
BHEIGHT*self.abacus.scale,
self.black),
(14-self.bead_count[i])*BHEIGHT*\
self.abacus.scale,
1.0/self.bead_count[i]))
for r in self.rods:
r.type = "frame"
def __init__(self, sprites, name, x, y, svg_engine, calculate, result,
offset, label, min, max, step):
svg = svg_engine(name, offset, label, min, max, step)
self.error_msg = svg.error_msg
self.spr = Sprite(sprites, x, y, svg_str_to_pixbuf(svg.svg))
self.calculate = calculate
self.result = result
self.name = name
def __init__(self, turtle_window, n):
'''This class handles the display of palette selectors (Only relevant
to GNOME version and very old versions of Sugar).
'''
self.shapes = []
self.spr = None
self._turtle_window = turtle_window
self._index = n
if not n < len(palette_names):
# Shouldn't happen, but hey...
debug_output('palette index %d is out of range' % n,
self._turtle_window.running_sugar)
self._name = 'extras'
else:
self._name = palette_names[n]
icon_pathname = None
for path in self._turtle_window.icon_paths:
if os.path.exists(os.path.join(path, '%soff.svg' % (self._name))):
icon_pathname = os.path.join(path, '%soff.svg' % (self._name))
break
if icon_pathname is not None:
off_shape = svg_str_to_pixbuf(svg_from_file(icon_pathname))
else:
off_shape = svg_str_to_pixbuf(
svg_from_file(
os.path.join(self._turtle_window.icon_paths[0],
'extrasoff.svg')))
error_output('Unable to open %soff.svg' % (self._name),
self._turtle_window.running_sugar)
icon_pathname = None
for path in self._turtle_window.icon_paths:
if os.path.exists(os.path.join(path, '%son.svg' % (self._name))):
icon_pathname = os.path.join(path, '%son.svg' % (self._name))
break
if icon_pathname is not None:
on_shape = svg_str_to_pixbuf(svg_from_file(icon_pathname))
else:
on_shape = svg_str_to_pixbuf(
svg_from_file(
os.path.join(self._turtle_window.icon_paths[0],
'extrason.svg')))
error_output('Unable to open %son.svg' % (self._name),
self._turtle_window.running_sugar)
self.shapes.append(off_shape)
self.shapes.append(on_shape)
x = int(ICON_SIZE * self._index)
self.spr = Sprite(self._turtle_window.sprite_list, x, 0, off_shape)
self.spr.type = 'selector'
self.spr.name = self._name
self.set_layer()
def __init__(self, nome: str, x: int, y: int, poder_atual: PoderGenerico, poder_armazenado: PoderGenerico, paletas_coletadas: int):
##### ATRIBUTOS GERAIS #####
self.__vida = 5
self.__sprite = {"cinza": Sprite("rabisco_cinza"),
"laranja": Sprite("rabisco_laranja"),
"vermelho": Sprite("rabisco_vermelho"),
"roxo": Sprite("rabisco_roxo"),
"azul": Sprite("rabisco_azul"),
"verde": Sprite("rabisco_verde"),
"marrom": Sprite("rabisco_marrom")}
self.__posicao_comeco = (x, y)
self.__descanso_troca_poder = 0
##### ATRIBUTOS POSICIONAIS #####
altura = 45
largura = 45
limite_vel = 5
self.__aceleracao = 0
##### ATRIBUTOS COMPORTAMENTAIS #####
self.__tipos_transparentes = [BolaFogo, Vitoria]
self.__poder = poder_atual
self.__poder_armazenado = poder_armazenado
self.__recuperacao = 0
self.__recarga = 0
self.__invisivel = 0
self.__moedas = 0
self.escala_tempo = 1
self.__paleta = paletas_coletadas
self.__auxiliar = 0 #usado para fazer o jogador pular no instane que toca no castelo
self.__congelado = False
super().__init__(nome, x, y, altura, largura, limite_vel, "0", [], (128,128,128))
def __init__(self, sprites, path, name, x, y, w, h):
self.spr = Sprite(sprites, x, y, file_to_pixbuf(path, name, w, h))
self.spr.label = "1.0"
self.spr.type = name
self.name = name
self.width = w
self.textview = None
self.textbuffer = None
self.fixed = None
self.textview_y_offset = 0
def __init__(self, size=10, pool=100):
self.size = size #realworld unit. 1 means 1pix for 1'unit'. 0.1 means 0.1'units' per pix
self.pixpermap = (300, 300)
self.pool = pool
self._contents = dict()
self._totalgets = 0
self._requestqueue = dict()
self._inflightqueue = []
self.nasprite = Sprite(size=self.pixpermap, transparent=False)
self.lock = Semaphore()
def __init__(self,
sprites,
path,
card_dim,
scale,
c,
x,
y,
shape='circle'):
""" Load a card from a precomputed SVG. """
self.images = []
self.orientation = 0
if shape == 'triangle':
file = "%s/triangle-r0-%d.svg" % (path, c)
self.increment = 60
elif shape == 'hexagon':
file = "%s/hexagon-r0-%d.svg" % (path, c)
self.increment = 120
else:
file = "%s/card-%d.svg" % (path, c)
self.increment = 90
self.images.append(load_image(file, card_dim * scale,
card_dim * scale))
if shape == 'triangle':
file = "%s/triangle-r60-%d.svg" % (path, c)
self.images.append(
load_image(file, card_dim * scale, card_dim * scale))
file = "%s/triangle-r120-%d.svg" % (path, c)
self.images.append(
load_image(file, card_dim * scale, card_dim * scale))
file = "%s/triangle-r180-%d.svg" % (path, c)
self.images.append(
load_image(file, card_dim * scale, card_dim * scale))
file = "%s/triangle-r240-%d.svg" % (path, c)
self.images.append(
load_image(file, card_dim * scale, card_dim * scale))
file = "%s/triangle-r300-%d.svg" % (path, c)
self.images.append(
load_image(file, card_dim * scale, card_dim * scale))
elif shape == 'hexagon':
file = "%s/hexagon-r120-%d.svg" % (path, c)
self.images.append(
load_image(file, card_dim * scale, card_dim * scale))
file = "%s/hexagon-r240-%d.svg" % (path, c)
self.images.append(
load_image(file, card_dim * scale, card_dim * scale))
else:
for r in range(3):
self.images.append(self.images[r].rotate_simple(90))
# create sprite from svg file
self.spr = Sprite(sprites, x, y, self.images[0])
def __init__(self, turtles, turtle_name, turtle_colors=None):
''' The turtle is not a block, just a sprite with an orientation '''
self.spr = None
self.label_block = None
self._turtles = turtles
self._shapes = []
self._custom_shapes = False
self._name = turtle_name
self._hidden = False
self._remote = False
self._x = 0.0
self._y = 0.0
self._heading = 0.0
self._half_width = 0
self._half_height = 0
self._drag_radius = None
self._pen_shade = 50
self._pen_color = 0
self._pen_gray = 100
if self._turtles.turtle_window.coord_scale == 1:
self._pen_size = 5
else:
self._pen_size = 1
self._pen_state = True
self._pen_fill = False
self._poly_points = []
self._prep_shapes(turtle_name, self._turtles, turtle_colors)
# Create a sprite for the turtle in interactive mode.
if turtles.sprite_list is not None:
self.spr = Sprite(self._turtles.sprite_list, 0, 0, self._shapes[0])
self._calculate_sizes()
# Choose a random angle from which to attach the turtle
# label to be used when sharing.
angle = uniform(0, pi * 4 / 3.0) # 240 degrees
width = self._shapes[0].get_width()
radius = width * 0.67
# Restrict the angle to the sides: 30-150; 210-330
if angle > pi * 2 / 3.0:
angle += pi / 2.0 # + 90
self.label_xy = [
int(radius * sin(angle)),
int(radius * cos(angle) + width / 2.0)
]
else:
angle += pi / 6.0 # + 30
self.label_xy = [
int(radius * sin(angle) + width / 2.0),
int(radius * cos(angle) + width / 2.0)
]
self._turtles.add_to_dict(turtle_name, self)
