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 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, 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 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 __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 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 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 __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 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 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 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 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 paint_screen(color, *rect):
    screen = get_surface()
    if not rect:
        screen.fill(color)
        update()
    else:
        screen.fill(color, rect)
        update(rect)

    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 __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 __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 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)