def draw(self):
viewport = display.get_surface()
if self.menu_state == "ok":
self.menu_state = "dim_out_1"
if self.menu_state == "dim_out_1":
if not self.dimmer:
self.dimmer = pygame.Surface(display.get_surface().get_size())
self.dimmer.fill((0, 0, 0))
self.dimmer.set_alpha(self.dim)
self.dim += 1
viewport.blit(self.dimmer, (0, 0))
if self.dim > 30:
self.menu_state = "dim_in_zoom"
self.dimmer = None
if self.menu_state in ("dim_in_zoom", "wait"):
if not self.dimmer:
self.dimmer = pygame.Surface(display.get_surface().get_size())
scaled = transform.scale(self.screen, self.zoom_size)
viewport.blit(scaled,
((-scaled.get_width() + VWIDTH)/2,
(-scaled.get_height() + VHEIGHT)/2))
self.draw_score(viewport)
self.draw_highscores(viewport)
self.scores.add_score(self.points)
if self.menu_state == "dim_in_zoom":
self.dimmer.set_alpha(self.dim)
self.dim -= 1
self.zoom_size[0] -= 10
self.zoom_size[1] -= 10
viewport.blit(self.dimmer, (0, 0))
if self.dim < 4:
self.menu_state = "wait"
def draw(self):
viewport = display.get_surface()
if self.menu_state == "ok":
self.menu_state = "dim_out_1"
if self.menu_state == "dim_out_1":
if not self.dimmer:
self.dimmer = pygame.Surface(display.get_surface().get_size())
self.dimmer.fill((0, 0, 0))
self.dimmer.set_alpha(self.dim)
self.dim += 1
viewport.blit(self.dimmer, (0, 0))
if self.dim > 30:
self.menu_state = "dim_in_zoom"
self.dimmer = None
if self.menu_state in ("dim_in_zoom", "wait"):
if not self.dimmer:
self.dimmer = pygame.Surface(display.get_surface().get_size())
scaled = transform.scale(self.screen, self.zoom_size)
viewport.blit(scaled, ((-scaled.get_width() + VWIDTH) / 2,
(-scaled.get_height() + VHEIGHT) / 2))
self.draw_score(viewport)
self.draw_highscores(viewport)
self.scores.add_score(self.points)
if self.menu_state == "dim_in_zoom":
self.dimmer.set_alpha(self.dim)
self.dim -= 1
self.zoom_size[0] -= 10
self.zoom_size[1] -= 10
viewport.blit(self.dimmer, (0, 0))
if self.dim < 4:
self.menu_state = "wait"
def __init__(self):
self.gameSurf = display.get_surface().copy()
self.drawWindow = display.get_surface()
backgroundColor = (31, 97, 141, 150)
title = SysFont('lucidaconsole', 35)
subtitle = SysFont('lucidaconsole', 25)
#distance between title and subtitle text
textMargin = 10
#distance between edge of text and full opacity background
textBackgroundMargin = 10
self.titleSurf = title.render("Cheat mode", True, Color('black'))
self.subtitleSurf = subtitle.render("Click to exit", True,
Color('black'))
self.textBackgroundSurf = surface.Surface(
(self.subtitleSurf.get_width() + 2 * textBackgroundMargin + 75,
self.titleSurf.get_height() + self.subtitleSurf.get_height() +
textMargin + 2 * textBackgroundMargin + 25), constants.SRCALPHA)
self.textBackgroundSurf.fill(backgroundColor)
self.titlePos = (self.drawWindow.get_width() / 2 -
self.titleSurf.get_width() / 2,
self.drawWindow.get_height() / 2 -
self.titleSurf.get_height() - textMargin / 2)
self.subtitlePos = (self.drawWindow.get_width() / 2 -
self.subtitleSurf.get_width() / 2,
self.drawWindow.get_height() / 2 + textMargin / 2)
self.textBackgroundPos = (self.drawWindow.get_width() / 2 -
self.textBackgroundSurf.get_width() / 2,
self.drawWindow.get_height() / 2 -
self.textBackgroundSurf.get_height() / 2)
def message_display(text, x, y, isCenter=False):
largeText = pygame.font.Font('Fonts/8-bit Arcade In.ttf', 30)
TextSurf, TextRect = text_objects(text, largeText)
if isCenter:
TextRect.center = (x, y)
else:
TextRect.x = x
TextRect.y = y
display.get_surface().blit(TextSurf, TextRect)
def draw_game():
window = display.get_surface()
display.get_surface().fill(color)
message_display("%d Lives" % lives[0], 20, 20)
message_display("%d Lives" % lives[1], 680, 20)
pygame.draw.rect(window, (255, 255, 255), playerOne)
pygame.draw.rect(window, (255, 255, 255), playerTwo)
pygame.draw.circle(window, (255, 255, 255), (int(ballX), int(ballY)), 2)
if isGameOver:
message_display(winner + " Wins", width / 2, 20, isCenter=True)
def after_turn(self):
if self.f.winner():
out = self.handler.onWin()
s = smallfont.render(out, True, Color('#000000'), Color('#ffffff'))
sw, sh = s.get_size()
display.get_surface().blit(s, (((self.xsize * self.fieldsize) - sw) / 2, 0))
display.update()
while pygame.event.wait().type != QUIT:
pass
return True
self.player = self.newplayer()
self.handler.player = self.player
def after_turn(self):
if self.f.winner():
out = self.handler.onWin()
s = smallfont.render(out, True, Color('#000000'), Color('#ffffff'))
sw, sh = s.get_size()
display.get_surface().blit(
s, (((self.xsize * self.fieldsize) - sw) / 2, 0))
display.update()
while pygame.event.wait().type != QUIT:
pass
return True
self.player = self.newplayer()
self.handler.player = self.player
def update(self, keys):
self.__setDir(keys)
self.__handleDirection()
self.__resetDir()
self.Rectangle.x = self.position[0]
self.Rectangle.y = self.position[1]
draw.rect(display.get_surface(), (255, 0, 0), self.Rectangle)
draw.circle(
display.get_surface(), (255, 0, 0),
(self.position[0], self.position[1] + int(self.size[1] / 2)),
int(self.size[1] / 2))
draw.circle(display.get_surface(), (255, 0, 0),
(self.position[0] + self.size[0],
self.position[1] + int(self.size[1] / 2)),
int(self.size[1] / 2))
def pause(display):
global main_score
screen = display.get_surface()
hsfont = font.Font(FONT, 100)
ysfont = font.Font(FONT, 100)
hs = hsfont.render("HIGH SCORE :-->" + str(highscore / 2), True,
HIGHSCORE_COLOR)
y_score = ysfont.render("YOUR SCORE :-->" + str(main_score / 2), True,
Y_SCORE_COLOR)
main_score = 0
#score = 0
pause_img = image.load('pause.png').convert_alpha()
pause_img = transform.scale(pause_img, (1200, 700))
screen.blit(pause_img, (
0,
0,
))
screen.blit(hs, (200, 60))
screen.blit(y_score, (200, 200))
display.flip()
while True:
for i in event.get():
if i.type == MOUSEBUTTONDOWN or i.type == KEYDOWN:
return main()
def fit_image(img):
"resize the image to fit the imgv window"
screen = get_surface()
gl.SCALE_UP = 0
if gl.REAL_WIDTH > gl.REAL_HEIGHT:
r = float(gl.REAL_WIDTH) / float(gl.REAL_HEIGHT)
new_width = screen.get_width()
new_height = int(new_width / r)
scale_val = new_width, new_height
img = scale(img, scale_val)
gl.SHRUNK = 1
elif gl.REAL_WIDTH < gl.REAL_HEIGHT:
r = float(gl.REAL_HEIGHT) / float(gl.REAL_WIDTH)
new_height = screen.get_height()
new_width = int(new_height / r)
scale_val = new_width, new_height
img = scale(img, scale_val)
gl.SHRUNK = 1
elif gl.REAL_WIDTH == gl.REAL_HEIGHT:
r = float(gl.REAL_WIDTH) / float(gl.REAL_HEIGHT)
new_height = screen.get_height()
new_width = screen.get_width()
if new_height > new_width:
scale_val = int(new_width / r), int(new_width / r)
elif new_width > new_height:
scale_val = int(new_height / r), int(new_height / r)
else:
scale_val = new_width, new_height
img = scale(img, scale_val)
else:
new_height = new_width = screen.get_width()
scale_val = new_width, new_height
img = scale(img, scale_val)
return img
def command_fullscreen():
"Toggle between full screen and last screen resolution"
screen = get_surface()
wait_cursor()
if not toggle_fullscreen():
try:
if gl.FULLSCREEN_SPECIAL:
screen_res = screen.get_size()
else:
screen_res = screen.get_size()
gl.MAX_SCREEN_FILES = gl.MAX_SF["%sx%s" % (
screen_res[0], screen_res[1])]
if not gl.TOGGLE_FULLSCREEN_SET: # go into fullscreen mode
gl.BEFORE_WINSIZE = screen.get_size()
screen = set_mode(screen_res, screen.get_flags(
) ^ FULLSCREEN, screen.get_bitsize())
else: # returning from fullscreen. Go back to last screen size:
set_mode(gl.BEFORE_WINSIZE, screen.get_flags(
) ^ FULLSCREEN, screen.get_bitsize())
screen = set_mode(
gl.BEFORE_WINSIZE, RESIZABLE) # make resizeable
my_toggle_fullscreen()
except:
print "Couldn't toggle fullscreen. Resolution probably not supported by your video card."
return screen
def get_center(screen, new_img):
"find out where the center of the screen is"
screen = get_surface()
screen_center = screen.get_rect().center
rect = new_img.get_rect()
rect.center = screen_center
return rect
def update(self, plitki=[]):
if len(plitki) > 1:
for pl in plitki:
if self != pl:
if collide_rect(self, pl):
if self.rect.x < pl.rect.x:
self.rect.x -= 1
pl.rect.x += 1
elif self.rect.x > pl.rect.x:
self.rect.x += 1
pl.rect.x -= 1
if self.rect.y < pl.rect.y:
self.rect.y -= 1
pl.rect.y += 1
elif self.rect.y > pl.rect.y:
self.rect.y += 1
pl.rect.y -= 1
surf = get_surface()
if self.rect.x <= 0:
self.rect.x += 1
if self.rect.y <= 0:
self.rect.y += 1
if self.rect.x+self.rect.w >= surf.get_width():
self.rect.x -= 1
if self.rect.y+self.rect.h >= surf.get_height():
self.rect.y -= 1
if self.mouse_on_button():
self.image.fill((255-self.color[0], 255-self.color[1], 255-self.color[2]))
rect(self.image, (125, 125, 125), (0, 0, self.rect.width, self.rect.height), 1)
self.image.blit(self.font.render(self.text, 1, self.color), (3, 3))
else:
self.image.fill(self.color)
rect(self.image, (255, 255, 255), (0, 0, self.rect.width, self.rect.height), 1)
self.image.blit(self.font.render(self.text, 1, (255-self.color[0], 255-self.color[1], 255-self.color[2])), (3, 3))
def __init__(self):
scrsize = self.w, self.h = display.get_surface().get_size()
Surface.__init__(self, scrsize)
self.foo = 0
self.l0 = []
self.l1 = []
self.l2 = []
def __init__(self, x, y, axis=True, grid=True):
""" initialise a plot object, with an
x-range from x[0] to x[1] and a
y-range from y[0] to y[1].
optional arguments axis and grid to set wether or not
the axis / grid should be shown by default.
the attributes are free to be get or set.
plot( (lower x, upper x), (lower y, upper y), axis = True, grid = True ) -> plot
to show the axis, grid and legend, use
plot.show()
to show functions and DE phase space, use
plot.draw_func( f(x) )
plot.draw_field( y'(x,y) )
"""
self.lo_x, self.hi_x = x
self.lo_y, self.hi_y = y
self.screen = display.get_surface()
self.axis_font = pgfont.SysFont('Cambria', 15, True)
self.axis = axis
self.grid = grid
self.dragging = False
def run(self):
window = display.get_surface()
for evt in event.get():
if evt.type == pygame.QUIT:
self.quit()
elif evt.type == pygame.MOUSEMOTION:
self.processMouseMotion(evt.pos)
elif evt.type == pygame.KEYDOWN:
self.processKeyDown(evt.key)
elif evt.type == pygame.MOUSEBUTTONDOWN:
self.processMouseButtonDown(evt.pos)
elif evt.type == pygame.MOUSEBUTTONUP:
self.processMouseButtonUp(evt.pos)
window.fill(self.aColor)
# self.testObj.rect.x = self.mouseX
# self.testObj.rect.y = self.mouseY
# self.activeSprites.draw(window)
self.activeState.update(self.Clock.get_time())
self.activeState.activeSprites.draw(window)
if len(self.activeState.pts) > 1:
draw.lines(window, (255, 0, 255), False, self.activeState.pts, 3)
self.Clock.tick(30)
display.flip()
self.run()
def draw(self):
# Desktop draws directly on screen
# Supposing method update was called before this, all widgets have redrawn their
# private surfaces so they are ready to be drawn on the screen.
for widget in self.widgets:
widget.draw(display.get_surface())
def render(self):
super(WindowLayer, self).render()
screen = display.get_surface()
gfxdraw.box(screen, (self.x + 1, self.y + 1, self.x2 - 1, self.y2 - 1),
self.bgcolor)
gfxdraw.rectangle(screen, (self.x, self.y, self.x2, self.y2),
self.fgcolor)
def build(settings):
pygame.init()
fullscreen = True
if fullscreen:
depth = 0
flags = FULLSCREEN | HWSURFACE | DOUBLEBUF
else:
depth = 16
flags = SWSURFACE | DOUBLEBUF
modes = display.list_modes(depth, flags)
if fullscreen:
if modes == -1: # Welcome to exceptionlessland
raise SystemExit("Failed to initialize display")
else:
mode = max(modes)
else:
mode = (settings.screen_width,settings.screen_height)
display.set_mode(mode, flags)
#print(modes)
#print(mode[0])
#print(mode[1])
return (display.get_surface(),mode[0],mode[1])
def draw(self):
#Desktop draws directly on screen
#Supposing method update was called before this, all widgets have redrawn their
#private surfaces so they are ready to be drawn on the screen.
for widget in self.widgets:
widget.draw(display.get_surface())
def draw_image(surface=None, image_file=None):
'''
Draw the provided image on the global display
Args:
surface (pygame.display): On which display to draw.
image_file (str or buffer): File path on disk or binary buffer
Returns:
bool: True or False indicating sucess and that the display should be updated
'''
update_display = False
surface = display.get_surface() if None in [surface] else surface
if None in [surface, image_file]:
_get_logger().warning("Missing required argument. No-op.")
else:
_get_logger().info("Trying to scale the image...")
# pylint: disable=bare-except
try:
picture = scale_image(img=image_file, size=surface.get_size())
# clear the previous displayed image
surface.fill(pygame.Color('black'))
imagepos = picture.get_rect()
imagepos.centerx = surface.get_rect().centerx
imagepos.centery = surface.get_rect().centery
surface.blit(picture, imagepos)
update_display = True
except:
update_display = False
return update_display
def __init__(self):
self.screen = display.get_surface()
self.w, self.h = self.screen.get_size()
self.horizon = [self.w / 2.0, self.h / 2.0, 500.0]
self.camera = [self.w / 2.0, self.h / 2.0, -100.0]
self.light_source = self.camera[:]
self.zoom = self.set_zoom()
def __init__(self):
screen_w, screen_h = display.get_surface().get_size()
self.health_bar = Bar(
Rect(10, screen_h - 20, 300, 10), 100, (200, 0, 0))
self.name_plates = NamePlates()
self.player_name = ""
def runtrial(self):
surface = display.get_surface()
surface.fill((255,255,255))
surface.blit(self.image,TOPLEFT)
display.flip()
self.sound.play()
time.sleep(ST_LENGTH)
surface.blit(self.fill,TOPLEFT)
display.flip()
time.sleep(TB_LENGTH)
keypresses = []
for e in event.get(KEYDOWN):
keypresses += [e.dict['unicode']]
if SPACE in keypresses:
return None
if unicode(KEYLEFT) in keypresses:
if self.trgtimg:
#print "user hit key \""+ KEYLEFT +"\" correctly"
self.result[0] = True
else:
#print "user hit key \""+ KEYLEFT +"\" incorrectly"
self.result[0] = False
if unicode(KEYRIGHT) in keypresses:
if self.trgtsnd:
#print "user hit key \""+ KEYRIGHT +"\" correctly"
self.result[1] = True
else:
#print "user hit key \""+ KEYRIGHT +"\" incorrectly"
self.result[1] = False
return True
def pause(display):
global main_score
screen = display.get_surface()
hsfont = font.Font(FONT, 100)
ysfont = font.Font(FONT,100)
hs = hsfont.render("HIGH SCORE :-->" + str(highscore/2), True, HIGHSCORE_COLOR)
y_score = ysfont.render("YOUR SCORE :-->"+str(main_score/2), True, Y_SCORE_COLOR)
main_score = 0
#score = 0
pause_img=image.load('pause.png').convert_alpha()
pause_img=transform.scale(pause_img, (1200, 700))
screen.blit(pause_img, (0, 0,))
screen.blit(hs, (200, 60))
screen.blit(y_score, (200, 200))
display.flip()
while True:
for i in event.get():
if i.type == MOUSEBUTTONDOWN or i.type == KEYDOWN:
return main()
def next_frame(self, action):
pump()
reward = 0.1
terminal = False
# Check input action
if action == 1:
self.current_velocity_y = self.upward_speed
self.is_flapped = True
# Update score
bird_center_x = self.bird_x + self.bird_width / 2
for pipe in self.pipes:
pipe_center_x = pipe["x_upper"] + self.pipe_width / 2
if pipe_center_x < bird_center_x < pipe_center_x + 5:
self.score += 1
reward = 1
break
# Update index and iteration
if (self.iter + 1) % 3 == 0:
self.bird_index = next(self.bird_index_generator)
self.iter = 0
self.base_x = -((-self.base_x + 100) % self.base_shift)
# Update bird's position
if self.current_velocity_y < self.max_velocity_y and not self.is_flapped:
self.current_velocity_y += self.downward_speed
if self.is_flapped:
self.is_flapped = False
self.bird_y += min(self.current_velocity_y, self.bird_y - self.current_velocity_y - self.bird_height)
if self.bird_y < 0:
self.bird_y = 0
# Update pipes' position
for pipe in self.pipes:
pipe["x_upper"] += self.pipe_velocity_x
pipe["x_lower"] += self.pipe_velocity_x
# Update pipes
if 0 < self.pipes[0]["x_lower"] < 5:
self.pipes.append(self.generate_pipe())
if self.pipes[0]["x_lower"] < -self.pipe_width:
del self.pipes[0]
if self.is_collided():
terminal = True
reward = -1
self.__init__()
# Draw everything
if self.screen is not None:
self.screen.blit(self.background_image, (0, 0))
self.screen.blit(self.base_image, (self.base_x, self.base_y))
self.screen.blit(self.bird_images[self.bird_index], (self.bird_x, self.bird_y))
for pipe in self.pipes:
self.screen.blit(self.pipe_images[0], (pipe["x_upper"], pipe["y_upper"]))
self.screen.blit(self.pipe_images[1], (pipe["x_lower"], pipe["y_lower"]))
image = array3d(display.get_surface())
display.update()
self.fps_clock.tick(self.fps)
return image, reward, terminal
def __init__(self, game, player, zoom):
self.game = game
self._player = player
self.zoom = zoom
self.definetiles()
self.makescreen(display.get_surface().get_size())
def __initPython(self, windowSize):
self.__windowSize = windowSize
self.__window = display.set_mode(self.__windowSize)
display.set_caption("Atlas Chronicle Game Engine")
self.__screen = display.get_surface()
self.__canvas = Surface(self.__windowSize)
def paint_screen(color, *rect):
screen = get_surface()
if not rect:
screen.fill(color)
update()
else:
screen.fill(color, rect)
update(rect)
def render(self):
window = display.get_surface()
for group in self.groups.values():
self.render_group.add(group.sprites())
for sprite in self.render_group.sprites():
self.render_group.change_layer(sprite, sprite.layer)
sprite.pre_draw()
return self.render_group.draw(window, self.background)
def __init__(self,image):
self.scr = display.get_surface()
w,h = image.get_size()
w //= 3
self.images = [image.subsurface(x,0,w,h).copy() for x in range(0,w*3,w)]
Rect.__init__(self,0,0,w,h)
self.ACTIV = True
self.status = False
self.over = False
def draw_all(self):
"""
Draws the whole game.
Arguments:
- `self`:
"""
disp = display.get_surface()
self.draw(disp)
def draw(self, username):
screen = display.get_surface()
for name in self.vehicles.keys():
if name == username:
text = self.fonts.render(name, 1, (0,255,0))
screen.blit(text, self.vehicles[name])
else:
text = self.fonts.render(name, 1, (255,0,0))
screen.blit(text, self.vehicles[name])
def __initPython(self, windowSize):
self.__windowSize = windowSize
self.__window = display.set_mode(self.__windowSize)
display.set_caption("Fractal Engine")
self.__screen = display.get_surface()
self.__canvas = Surface(self.__windowSize)
self.__canvas.fill((100,100,100))
def initLoadScreen(group, textBar):
global curGroup, screen, curTextBar, background
screen = Display.get_surface()
background = pygame.image.load(LOADIMG)
screen.blit(background, background.get_rect())
curGroup = group
curTextBar = textBar
curGroup.draw(screen)
Display.flip()
def __init__(self):
RenderPlain.__init__(self)
display_surf = display.get_surface()
d_width = display_surf.get_width()
d_heigth = display_surf.get_height()
self.background = None
self.rect = Rect(0, 0, d_width, d_heigth)
self.buttons = []
self.input = None
def initLoadScreen(group, textBar):
global curGroup, screen, curTextBar, background
screen = Display.get_surface()
background = pygame.image.load(LOADIMG)
screen.blit(background, background.get_rect())
curGroup = group
curTextBar = textBar
curGroup.draw(screen)
Display.flip()
def draw_all(self):
"""
Draws the whole game.
Arguments:
- `self`:
"""
disp = display.get_surface()
self.draw(disp)
def __init__(self):
super(GameScene, self).__init__()
self.w, self.h = display.get_surface().get_size()
self.allq = sprite.Group()
self.spriteq = sprite.Group()
self.textq = sprite.Group()
self.bulletq = sprite.Group()
self.visuals = self.spriteq, self.textq
self.directions = [[x, y] for x in (-1, 0, 1) for y in (-1, 0, 1) if [x, y] != [0, 0]]
def draw(self):
screen = display.get_surface()
draw.rect(screen, (50, 50, 50), self.rect, 0)
width = self.ratio * self.rect.w
bar_rect = Rect(self.rect.x + 2, self.rect.y + 2,
width - 4, self.rect.h - 4)
draw.rect(screen, self.color, bar_rect)
def __init__(self,width,height,title=DEFAULT_TITLE,display_color=DEFAULT_COLOR,icon=DEFAULT_ICON_PATH):
display.set_mode([width,height])
display.set_caption(title)
display.set_icon(image.load(icon))
self.__display = display.get_surface()
self.__color = display_color
self.drawDisplay()
def __init__(self):
D.init()
F.init()
D.set_mode((0, 0), pygame.NOFRAME)
self.main_surface = D.get_surface()
background = I.load("DB.jpg").convert()
self.main_surface.blit(background, (0, 0))
D.flip()
D.set_caption("DIVE")
def __init__(self, label='', fgcolor=(255, 255, 255), font=None):
if not font: font = Coche.font
Rect.__init__(self, Coche.coche0.get_rect())
self.scr = display.get_surface()
self.status = False
label = Coche.font.render(label, 1, fgcolor)
Rlabel = label.get_rect()
Rlabel.midleft = self.midright
self.label = Surface(self.union(Rlabel).size, SRCALPHA)
self.label.blit(label, Rlabel)
def update(cls):
fondo = display.get_surface()
fondo.fill((0, 0, 0))
if cls.on_selection:
draw.rect(fondo, cls.selection.color, cls.selection.rect, 1)
cls.blocks.update()
cls.blocks.draw(fondo)
display.update()
def render(self):
super(LineShapeLayer, self).render()
screen = display.get_surface()
color = (255, 255, 255)
if self.parent:
color = self.parent.color
gfxdraw.line(screen, self.x + self.app.context.offset_x,
self.y + self.app.context.offset_y,
self.x2 + self.app.context.offset_x,
self.y2 + self.app.context.offset_y, color)
def __init__(self,label='',fgcolor=(255,255,255),font=None):
if not font: font = Coche.font
Rect.__init__(self,Coche.coche0.get_rect())
self.scr = display.get_surface()
self.status = False
label = Coche.font.render(label,1,fgcolor)
Rlabel = label.get_rect()
Rlabel.midleft = self.midright
self.label = Surface(self.union(Rlabel).size,SRCALPHA)
self.label.blit(label,Rlabel)
def __init__(self, image):
self.scr = display.get_surface()
w, h = image.get_size()
w //= 3
self.images = [
image.subsurface(x, 0, w, h).copy() for x in range(0, w * 3, w)
]
Rect.__init__(self, 0, 0, w, h)
self.ACTIV = True
self.status = False
self.over = False
def getLoadScreen():
screen = Display.get_surface()
splashGroup = SpriteGroup()
# Create text for connecting player
connectingText = TextBar ('Loading...', (0, 20, 250, 50), 35)
imgWidth = connectingText.image.get_width()
connectingText.rect.left = (screen.get_size()[X] - imgWidth) / 2
splashGroup.add(connectingText)
return splashGroup,connectingText
def getLoadScreen():
screen = Display.get_surface()
splashGroup = SpriteGroup()
# Create text for connecting player
connectingText = TextBar("Loading...", (0, 20, 250, 50), 35)
imgWidth = connectingText.image.get_width()
connectingText.rect.left = (screen.get_size()[X] - imgWidth) / 2
splashGroup.add(connectingText)
return splashGroup, connectingText
def my_update_screen(new_img, rect, file):
screen = get_surface()
screen.fill(gl.IMGV_COLOR)
screen.blit(new_img, rect)
update()
try:
if gl.IMG_BORDER:
img_border(new_img.get_width(), new_img.get_height(), rect)
img_info(gl.files[file], file, new_img)
except:
pass
def command_full_down(rect, last_rect, new_img, file):
"scroll image to all the way downward to see the very top"
screen = get_surface()
gl.HAND_TOOL = 1
if rect.top < 0:
rect.top = 0
screen.blit(new_img, rect)
update(rect.union(last_rect))
img_info(gl.files[file], file, new_img, gl.NS_GLOBAL[0])
drag_hand_cursor()
return rect
def command_full_right(rect, last_rect, new_img, file):
"scroll image to all the way to the right to see the very left side"
screen = get_surface()
gl.HAND_TOOL = 1
if rect.left < 0:
rect.left = 0
screen.blit(new_img, rect)
update(rect.union(last_rect))
img_info(gl.files[file], file, new_img, gl.NS_GLOBAL[0])
drag_hand_cursor()
return rect
def __init__(self, img, rect, t, ID=None):
PG.sprite.DirtySprite.__init__(self)
self.image = img
self.rect = rect
self.x = 0
self.y = 0
self.width = 0
self.height = 0
Globals.SCREEN = PDI.get_surface()
self.type = t
self.id = ID
def __init__(self, img, rect, t, ID=None):
PG.sprite.DirtySprite.__init__(self)
self.image = img
self.rect = rect
self.x = 0
self.y = 0
self.width = 0
self.height = 0
Globals.SCREEN = PDI.get_surface()
self.type = t
self.id = ID
def draw_display(self, rect):
display = get_surface()
for entity in self.entities.values():
if rect.colliderect(entity.rect):
display.blit(entity.img, (entity.pos[0] - rect.x, entity.pos[1] - rect.y))
for item in self.items:
if rect.colliderect(item.rect):
display.blit(item.item.image, (item.pos[0] - rect.x, item.pos[1] - rect.y))
for arr in self.projectiles:
for p in arr:
if rect.colliderect(p.rect):
display.blit(p.img, (p.pos[0] - rect.x, p.pos[1] - rect.y))
def command_full_up(rect, last_rect, new_img, file):
"scroll image all the way upward to see the very bottom"
screen = get_surface()
screen_height = screen.get_height()
gl.HAND_TOOL = 1
if rect.bottom > screen_height:
rect.bottom = screen_height
screen.blit(new_img, rect)
update(rect.union(last_rect))
img_info(gl.files[file], file, new_img, gl.NS_GLOBAL[0])
drag_hand_cursor()
return rect
def __init__(self, gameWon):
self.gameSurf = display.get_surface().copy()
self.drawWindow = display.get_surface()
self.transparentSurf = surface.Surface(
display.get_surface().get_size(), constants.SRCALPHA)
color = (0, 255, 0, 127) if gameWon else (255, 0, 0, 127)
text = "You Won!" if gameWon else "You Lost..."
backgroundColor = (0, 255, 0) if gameWon else (255, 0, 0)
title = SysFont('lucidaconsole', 25)
subtitle = SysFont('lucidaconsole', 15)
#distance between title and subtitle text
textMargin = 10
#distance between edge of text and full opacity background
textBackgroundMargin = 10
self.transparentSurf.fill(color)
self.titleSurf = title.render(text, True, Color('black'))
self.subtitleSurf = subtitle.render("Click to play again", True,
Color('black'))
self.textBackgroundSurf = surface.Surface(
(self.subtitleSurf.get_width() + 2 * textBackgroundMargin,
self.titleSurf.get_height() + self.subtitleSurf.get_height() +
textMargin + 2 * textBackgroundMargin))
self.textBackgroundSurf.fill(backgroundColor)
self.titlePos = (self.drawWindow.get_width() / 2 -
self.titleSurf.get_width() / 2,
self.drawWindow.get_height() / 2 -
self.titleSurf.get_height() - textMargin / 2)
self.subtitlePos = (self.drawWindow.get_width() / 2 -
self.subtitleSurf.get_width() / 2,
self.drawWindow.get_height() / 2 + textMargin / 2)
self.textBackgroundPos = (self.drawWindow.get_width() / 2 -
self.textBackgroundSurf.get_width() / 2,
self.drawWindow.get_height() / 2 -
self.textBackgroundSurf.get_height() / 2)
def updateLoadScreen(message):
global screen, curTextBar, curGroup, background
if (screen == None):
return
screen = Display.get_surface()
curGroup.clear(screen, background)
# Updated text
curTextBar.setText(message)
curTextBar.rect.centerx = screen.get_rect().centerx
curGroup.draw(screen)
Display.flip()
