def __init__(self, rows=3, cols=6):
     product = rows * cols
     if product % 2 != 0:
         raise ValueError("Product of rows and columns must be divisible by 2.")
     if product > NUM_CARDS * 2:
         raise ValueError("Product of rows and columns must not exceed {0:d}.".format(NUM_CARDS * 2))
     self.rows = rows
     self.cols = cols
     self.card_config = CardConfig(self.rows, self.cols)
     os.environ['SDL_VIDEO_CENTERED'] = '1'
     pygame.init()
     self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
     pygame.display.set_caption("Memory Game")
     self.clock = pygame.time.Clock()
     self.background = \
         gradients.vertical((SCREEN_WIDTH, SCREEN_HEIGHT), Game.DARK_GREEN, Game.GREEN)
     self.fade_rect = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT))
     self.fade_rect.set_alpha(96)
     self.fade_rect.fill((0, 0, 0))
     self.small_font = pygame.font.Font(None, 20)
     self.large_font = pygame.font.Font(None, 64)
     self.medium_font = pygame.font.Font(None, 28)
     self.game_over_msg_image = self.large_font.render(Game.GAME_OVER_MESSAGE, True, Game.YELLOW).convert_alpha()
     self.game_over_dir_image = self.medium_font.render(Game.GAME_OVER_DIRECTIONS, True, Game.WHITE).convert_alpha()
     self.reset()
     # Sound
     self.click_sound = load_sound("sounds\clickerx.wav")
     self.match_sound = load_sound("sounds\sparkle.wav")
     self.startup = load_sound("sounds\startup.wav")
     self.shutdown = load_sound("sounds\shutdown.wav")
     self.onsound = False
     self.offsound = False
Example #2
0
def display(title, message=None):
    message_text = None
    message_rect = None
    title_text = textrect(title, ui.typography["title"], width, colors.GOLD)
    title_rect = title_text.get_rect()
    title_rect.x += padding[3]
    title_rect.y += padding[0]
    tooltip_rect = pygame.Rect(0, 0, title_rect.w + padding[1] + padding[3], 
                               title_rect.h + padding[0] + padding[2])
    if message is not None:
        message_text = textrect(message, ui.typography["system"], width,
                                colors.WHITE)
        message_rect = message_text.get_rect()
        message_rect.x += padding[3]
        message_rect.y += title_rect.h + title_rect.y + separator_padding
        tooltip_rect.h += message_rect.h + separator_padding

    tooltip = pygame.surface.Surface((tooltip_rect.w, tooltip_rect.h))
    tooltip.blit(gradients.vertical((tooltip_rect.w, tooltip_rect.h), 
                                        colors.OPAQUE_DARK_GRAY, 
                                        colors.OPAQUE_BLACK), (0, 0))
    pygame.draw.rect(tooltip, colors.GOLD, tooltip_rect, 1)
    tooltip.blit(title_text, title_rect)

    if message_text is not None:
        tooltip.blit(message_text, message_rect)

    game_rect = game.background.get_rect()
    tooltip_rect.x = game.resolution[0] - tooltip_rect.w - margin[3]
    tooltip_rect.y = game.resolution[1] - tooltip_rect.h - margin[0]

    game.screen.blit(tooltip, tooltip_rect)
Example #3
0
    def __init__(self):
        self.screen_rect = states.TheStateManager.screen.get_rect()
        self.img = gradients.vertical(self.screen_rect.size, (0, 255, 255, 255), (80, 100, 135, 255))

        # Sun
        sunimg = pygame.transform.scale2x(pygame.image.load(data.filepath('sun.png'))).convert_alpha()
        self.sun = self.spr = animation.FrameAnimation((0, 0), sunimg)
        self.sun_radius = self.screen_rect.h * 0.8

        # Moon
        moonimg = pygame.image.load(data.filepath('moon.png')).convert_alpha()
        self.moon =  animation.FrameAnimation((0, 0), moonimg)
        self.moon_radius = self.screen_rect.h * 0.8

        # Generate starfield
        self.stars = pygame.Surface(self.screen_rect.size).convert()
        self.stars.fill((0, 255, 0))
        self.stars.set_alpha(None)
        self.stars.set_colorkey((0, 255, 0))
        self.stars.lock()
        for i in range(80):
            x = randint(0, self.screen_rect.width)
            y = randint(0, self.screen_rect.height)
            self.stars.set_at((x,y), (255,255,255))
        self.stars.unlock()

        self.night = pygame.Surface(self.screen_rect.size).convert()
        self.night.fill((0, 0, 0))
        self.night.set_alpha(None)
        self.night.set_colorkey(None)
        self.night.set_alpha(0)


        self.math_time = -0.25
Example #4
0
    def __init__(self):
        self.screen_rect = states.TheStateManager.screen.get_rect()
        self.img = gradients.vertical(self.screen_rect.size,
                                      (0, 255, 255, 255), (80, 100, 135, 255))

        # Sun
        sunimg = pygame.transform.scale2x(
            pygame.image.load(data.filepath('sun.png'))).convert_alpha()
        self.sun = self.spr = animation.FrameAnimation((0, 0), sunimg)
        self.sun_radius = self.screen_rect.h * 0.8

        # Moon
        moonimg = pygame.image.load(data.filepath('moon.png')).convert_alpha()
        self.moon = animation.FrameAnimation((0, 0), moonimg)
        self.moon_radius = self.screen_rect.h * 0.8

        # Generate starfield
        self.stars = pygame.Surface(self.screen_rect.size).convert()
        self.stars.fill((0, 255, 0))
        self.stars.set_alpha(None)
        self.stars.set_colorkey((0, 255, 0))
        self.stars.lock()
        for i in range(80):
            x = randint(0, self.screen_rect.width)
            y = randint(0, self.screen_rect.height)
            self.stars.set_at((x, y), (255, 255, 255))
        self.stars.unlock()

        self.night = pygame.Surface(self.screen_rect.size).convert()
        self.night.fill((0, 0, 0))
        self.night.set_alpha(None)
        self.night.set_colorkey(None)
        self.night.set_alpha(0)

        self.math_time = -0.25
Example #5
0
    def __init__(self, title, message, buttons={}):
        frame_title = "dialogue_{0}".format(title)
        self.frame = Frame(frame_title, x, y, width, height, z)
        self.frame.title = title
        self.buttons = buttons
        self.frame.closeable = True
        background = pygame.surface.Surface((width, height))
        background.blit(gradients.vertical((width, height), 
                                            colors.OPAQUE_GRAY, 
                                            colors.OPAQUE_BLACK), (0, 0))
        self.frame.background = background
        textbox = self.frame.background.subsurface(pygame.Rect(50, 40, 
                                                               text_width, 
                                                               text_height))
        button_rect = pygame.Rect(25, 60 + text_height, button_width, 25)
        button_area = self.frame.background.subsurface(button_rect)
        textrect(message, ui.typography["title"], text_width, colors.WHITE, 
                 surface=textbox)
        created_buttons = []
        for button_create in buttons:
            created_buttons.append(Button(button_create[0], button_create[1]))
        total = len(created_buttons)
        padding = (button_width - (total * button.width)) / (total + 1)

        button_index = 0
        for btn in created_buttons:
            btn_offset = button_area.get_abs_offset()
            btn_rect = pygame.Rect((padding * (button_index + 1)) + 
                                   (button.width * button_index), 0, 
                                   button.width, button.height)
            button_area.blit(btn.image, (btn_rect.x, btn_rect.y))
            btn_rect.x += btn_offset[0] + x
            btn_rect.y += btn_offset[1] + y
            game.addClickableFrame(btn_rect, self.frame, btn.action, 2)
            button_index += 1
Example #6
0
 def __init__(self):
     os.environ['SDL_VIDEO_CENTERED'] = '1'
     pygame.init()
     self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
     pygame.display.set_caption(Game.TEXT)
     self.message = Message(Game.TEXT)
     self.background = \
         gradients.vertical((SCREEN_WIDTH, SCREEN_HEIGHT), PURPLE, BLACK)
Example #7
0
 def __init__(self, label, action):
     """"""
     self.label = label
     self.action = action
     self.image = pygame.surface.Surface((width, height))
     self.image.blit(gradients.vertical((width, height), 
                                        colors.OPAQUE_DARK_RED,
                                        colors.OPAQUE_RED), (0, 0))
     textrect(label, ui.typography["subtitle"], width, colors.WHITE, 
              surface=self.image, align=1)
def getGradient(move, color, coor):
	white = (WHITE[0], WHITE[1], WHITE[2], 0)
	theColor = (color[0], color[1], color[2], 255)
	if move == 'up':
		begin = theColor
		end = white
		return gradients.vertical(coor, begin, end)
	elif move == 'left':
		begin = theColor
		end = white
		return gradients.horizontal(coor, begin, end)
	elif move == 'right':
		begin = white
		end = theColor
		return gradients.horizontal(coor, begin, end)
Example #9
0
 def __init__(self, pos, min_points, max_points, size, color):
     self.images = {}
     self.pos = pos
     self.min_points = min_points
     self.max_points = max_points
     self.max_sub_min = max_points - min_points
     for i in range(100+1):
         surf = pygame.Surface(size).convert()
         surf.fill((255, 0, 255))
         surf.set_colorkey((255, 0, 255))
         h = size[1] * i * 0.01
         if h:
             rect = pygame.Rect(0, size[1] - h, size[0], h)
             r, g, b = color
             tmp = gradients.vertical(rect.size, (r, g, b, 255), (255, 0, 0,  255)).convert()
             surf.blit(tmp, rect)
             #surf.fill(color, rect)
         pygame.draw.rect(surf, color, surf.get_rect(), 1)
         self.images[i] = surf
Example #10
0
 def __init__(self, pos, min_points, max_points, size, color):
     self.images = {}
     self.pos = pos
     self.min_points = min_points
     self.max_points = max_points
     self.max_sub_min = max_points - min_points
     for i in range(100 + 1):
         surf = pygame.Surface(size).convert()
         surf.fill((255, 0, 255))
         surf.set_colorkey((255, 0, 255))
         h = size[1] * i * 0.01
         if h:
             rect = pygame.Rect(0, size[1] - h, size[0], h)
             r, g, b = color
             tmp = gradients.vertical(rect.size, (r, g, b, 255),
                                      (255, 0, 0, 255)).convert()
             surf.blit(tmp, rect)
             #surf.fill(color, rect)
         pygame.draw.rect(surf, color, surf.get_rect(), 1)
         self.images[i] = surf
Example #11
0
 def update(self, dt, t, *args, **kwargs):
     # sky
     fullcircletime = 3*60*1000.0 # three minutes per round
     startingtime=0.25 # starting point as the fraction of a full circle (which equals one)
     self.math_time += dt/fullcircletime
     dayratio=0.3
     s = nightday(math.cos((self.math_time+startingtime) * 2 * math.pi), dayratio)
     s1 = int(round(127 * s))
     self.img = gradients.vertical(self.screen_rect.size,  (0, s1 + 128, s1 + 128, 255), (0, 0, 128+s1/4, 255))
     # sun
     offx, offy = self.sun.image.get_size()
     x = self.screen_rect.centerx - offx/2 + dayratio*3.8 * self.sun_radius * math.sin((self.math_time+startingtime) * 2 * math.pi)
     y = self.screen_rect.h - offy/2 - self.sun_radius * nightday(math.cos((self.math_time+startingtime) * 2 * math.pi),dayratio)
     self.sun.pos = (x, y)
     # moon
     offx, offy = self.moon.image.get_size()
     x = self.screen_rect.centerx - offx/2 + dayratio*3.8 * self.moon_radius * math.sin((self.math_time+startingtime) * 2 * math.pi + math.pi)
     y = self.screen_rect.h - offy/2 - self.sun_radius * nightday(math.cos((self.math_time+startingtime) * 2 * math.pi + math.pi),dayratio)
     self.moon.pos = (x, y)
     # stars
     self.stars.set_alpha(160*nightday(math.sin((self.math_time+startingtime) * 2 * math.pi+ math.pi * 1.5),dayratio)+84 )
     # night
     alpha = 40 + 40 * nightday(math.sin((self.math_time+startingtime) * 2 * math.pi + math.pi * 1.5), dayratio)
     self.night.set_alpha(alpha, pygame.RLEACCEL)
Example #12
0
 def update(self, dt, t, *args, **kwargs):
     # sky
     fullcircletime = 3 * 60 * 1000.0  # three minutes per round
     startingtime = 0.25  # starting point as the fraction of a full circle (which equals one)
     self.math_time += dt / fullcircletime
     dayratio = 0.3
     s = nightday(math.cos((self.math_time + startingtime) * 2 * math.pi),
                  dayratio)
     s1 = int(round(127 * s))
     self.img = gradients.vertical(self.screen_rect.size,
                                   (0, s1 + 128, s1 + 128, 255),
                                   (0, 0, 128 + s1 / 4, 255))
     # sun
     offx, offy = self.sun.image.get_size()
     x = self.screen_rect.centerx - offx / 2 + dayratio * 3.8 * self.sun_radius * math.sin(
         (self.math_time + startingtime) * 2 * math.pi)
     y = self.screen_rect.h - offy / 2 - self.sun_radius * nightday(
         math.cos((self.math_time + startingtime) * 2 * math.pi), dayratio)
     self.sun.pos = (x, y)
     # moon
     offx, offy = self.moon.image.get_size()
     x = self.screen_rect.centerx - offx / 2 + dayratio * 3.8 * self.moon_radius * math.sin(
         (self.math_time + startingtime) * 2 * math.pi + math.pi)
     y = self.screen_rect.h - offy / 2 - self.sun_radius * nightday(
         math.cos((self.math_time + startingtime) * 2 * math.pi + math.pi),
         dayratio)
     self.moon.pos = (x, y)
     # stars
     self.stars.set_alpha(160 * nightday(
         math.sin((self.math_time + startingtime) * 2 * math.pi +
                  math.pi * 1.5), dayratio) + 84)
     # night
     alpha = 40 + 40 * nightday(
         math.sin((self.math_time + startingtime) * 2 * math.pi +
                  math.pi * 1.5), dayratio)
     self.night.set_alpha(alpha, pygame.RLEACCEL)
Example #13
0
 def draw_gradient(self, rectangle, from_color, to_color):
     self.screen.blit(
         gradients.vertical((rectangle.width, rectangle.height), from_color,
                            to_color), (rectangle.left, rectangle.top))
Example #14
0
def main():
        pygame.init()
        screen = pygame.display.set_mode((800,700), pygame.SRCALPHA)
        bgd = pygame.Surface(screen.get_size())
        bgd.blit( gradients.vertical(bgd.get_size(), (227, 200, 53, 255), (157, 116, 2, 255)),(0,0))
        bgd.fill((128,)*3)
        screen.blit(bgd, (0,0))
        pygame.key.set_repeat(500, 30)

        def f1(x):
            return x
        def f2(x):
            return 0.49*math.cos(10*x)+0.5
        def f3(x):
            return 0.49*math.sin(100*x)+0.5
        def f4(x):
            return math.exp(x)
        def f5(x):
            return x*x
        def f6(x):
            return math.cos(1.5*x)
        def f7(x):
            return math.sqrt(x)
        def f8(x):
            return x%5
        def f9(x):
            return math.exp(-x/10.)*math.sin(x)
        def f10(x):
            return math.ceil(x/10.)
        def f11(x):
            return math.exp(x-10)+math.exp(-x-10)
        def f12(x):
            return x**2-x**4
        def f13(x):
            return 10*x+10
        def f14(x):
            if x<-math.pi/2.:
                return 0
            elif x>math.pi/2:
                return 2
            else:
                return math.sin(x)+1



        def expf(x,y=1):
##            return 0.49*math.sin(5*x)+0.5
##            return math.cos(x*30.)*math.sin(y*30.)
##            r = x**2+y**2
##            return 2-abs(x)*abs(y)
            return math.sin(15*y-math.sin(15*x))*math.cos(15*x-math.cos(15*y))*3
##            return 2*math.cos(20*r)*math.exp(-1./3*r)
##            return r**0.5
##            return math.exp(x*y)-math.exp(-y*x)
##            return (5*x)**(5*y)


        types  = ["line", "circle", "rect"]
        modes  = [0,1,2,3,4,5]
        type   = 0
        mode   = 0
        funcs  = [f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14]
        rf     = 1
        gf     = 1
        bf     = 1
        af     = 0
        spoint = (300,500)
        epoint = (320, 640)
        scol   = (0,255,0,100)
        ecol   = (100,0,50,255)
        offset = (0,0)

        pygame.display.set_caption( "mode:"+str(modes[mode])+
                                    " type:"+str(types[type])+
                                    " rf:"+str(rf)+
                                    " gf:"+str(gf)+
                                    " bf:"+str(bf)+
                                    " af:"+str(af)+
                                    "    keys: r,g,b,a,  t,m, ctrl+click"
                                    )
        running = True
        changed = True
        while running:
            event = pygame.event.wait()
            if pygame.QUIT==event.type:
                running = False
            elif pygame.KEYDOWN == event.type:
                if event.key == pygame.K_ESCAPE:#pygame.K_ESCAPE == event.key:
                    running = False
                elif event.key == pygame.K_t:
                    type += 1
                    type %= len(types)
                elif event.key == pygame.K_m:
                    mode += 1
                    mode %= len(modes)
                elif event.key == pygame.K_r:
                    rf += 1
                    rf %= len(funcs)
                elif event.key == pygame.K_g:
                    gf += 1
                    gf %= len(funcs)
                elif event.key == pygame.K_b:
                    bf += 1
                    bf %= len(funcs)
                elif event.key == pygame.K_a:
                    af += 1
                    af %= len(funcs)
                elif event.key == pygame.K_SPACE:
                    rint = random.randint
                    scol = (rint(1,254), rint(1,254), rint(1,254), rint(1,254))
                    ecol = (rint(1,254), rint(1,254), rint(1,254), rint(1,254))
                elif event.key == pygame.K_DOWN:
                    offset = (offset[0], offset[1]+1)
                elif event.key == pygame.K_UP:
                    offset = (offset[0], offset[1]-1)
                elif event.key == pygame.K_LEFT:
                    offset = (offset[0]-1, offset[1])
                elif event.key == pygame.K_RIGHT:
                    offset = (offset[0]+1, offset[1])
                changed = True
            elif pygame.MOUSEBUTTONDOWN == event.type:
                if pygame.key.get_mods()&pygame.KMOD_CTRL:
                    spoint = list(pygame.mouse.get_pos())
                else:
                    epoint = list(pygame.mouse.get_pos())
                changed = True

            if changed:
                changed = False
                mode_str = []
                if gradients.BLEND_MODES_AVAILABLE:
                    mode_str = ["normal", "add", "sub", "mult", "min", "max"]
                else:
                    mode_str = ["normal"]*6
                pygame.display.set_caption( "mode:"+mode_str[modes[mode]]+
                                            " type:"+str(types[type])+
                                            " rf:"+str(rf)+
                                            " gf:"+str(gf)+
                                            " bf:"+str(bf)+
                                            " af:"+str(af)+
                                            "    keys: r,g,b,a,  t,m, ctrl+click"+
                                            " space: chg color"
                                            )
                screen.fill((50,50,50))
                screen.blit(bgd, (0,0))
# genericFxyGradient
                #genericFxyGradient(screen, pygame.Rect(600,100,195,200), (0,100,200),(255,50,100), expf, (-2,2), (-2,2))
                # gradient
                func = gradients.draw_gradient
                if types[type]=="circle":
                    func = gradients.draw_circle
                elif types[type]=="rect":
                    func = gradients.draw_squared
                func(screen, spoint,epoint, scol, ecol, funcs[rf], funcs[gf], funcs[bf], funcs[af], modes[mode])

                pygame.draw.line(screen, (255,0,255), spoint, epoint)

                print "startcolor:",scol
                print "endcolor", ecol
                print "startpoint", spoint
                print "endpoint", epoint
                print "------------------"
                screen.blit(gradients.horizontal((198, 198), scol, ecol), (1,1))
                screen.blit(gradients.vertical((198,198), scol, ecol), (201, 1))
                screen.blit(gradients.radial(99, scol, ecol), (401, 1))
                screen.blit(gradients.squared(198, scol, ecol), (601, 1))

                screen.blit(gradients.horizontal_func((198, 198), scol, ecol, funcs[rf], funcs[gf], funcs[bf], funcs[af]), (1,201))
                screen.blit(gradients.vertical_func((198,198), scol, ecol, funcs[rf], funcs[gf], funcs[bf], funcs[af]), (201, 201))
                screen.blit(gradients.radial_func(99, scol, ecol, funcs[rf], funcs[gf], funcs[bf], funcs[af]), (401, 201))
                screen.blit(gradients.squared_func(198, scol, ecol, funcs[rf], funcs[gf], funcs[bf], funcs[af], offset), (601, 201))

                #screen.blit(gradients.chart(spoint, epoint, scol, ecol, funcs[rf], funcs[gf], funcs[bf], funcs[af]), (0,700-257))

                #screen.blit(gradients.radial_func_offset(99, scol, ecol, funcs[rf], funcs[gf], funcs[bf], funcs[af], offset=offset), (601, 401))

                pygame.display.flip()


        pygame.quit()
Example #15
0
 def __init__(self):
     self.screen_rect = states.TheStateManager.screen.get_rect()
     self.img = gradients.vertical(self.screen_rect.size,
                                   (0, 255, 255, 255), (80, 100, 135, 255))
Example #16
0
 def update(self, dt, t, *args, **kwargs):
     s = math.cos(t / 10000. * 2 * math.pi)
     s1 = int(round(127 * s))
     self.img = gradients.vertical(self.screen_rect.size,
                                   (0, s1 + 128, s1 + 128, 255),
                                   (0, 0, 128, 255))
Example #17
0
 def __init__(self):
     self.screen_rect = states.TheStateManager.screen.get_rect()
     self.img = gradients.vertical(self.screen_rect.size, (0, 255, 255, 255), (80, 100, 135, 255))
Example #18
0
 def update(self, dt, t, *args, **kwargs):
     s = math.cos(t/10000. * 2 * math.pi)
     s1 = int(round(127 * s))
     self.img = gradients.vertical(self.screen_rect.size,  (0, s1 + 128, s1 + 128, 255), (0, 0, 128, 255))