Exemple #1
0
 def blit_resources(self):
     v = self.ui_vars
     font = Font(self.CORE.font_family, self.CORE.fonts['resource'][0])
     txt_right = v.disp_w - v.rsr_icos - 2*v.rsr_spc
     ico_left = v.disp_w - v.rsr_icos - v.rsr_spc
     h = v.rsr_icos + v.rsr_spc
     self.screen.blit(self.gfx.icons['wood'], (ico_left, v.rsr_spc))
     self.screen.blit(self.gfx.icons['iron'], (ico_left, h+v.rsr_spc))
     self.screen.blit(self.gfx.icons['fuel'], (ico_left, 2*h+v.rsr_spc))
     plr = self.player
     wood_amount = font.render(str(plr.r_wood), False, self.colors.white)
     w_rect = wood_amount.get_rect()
     w_rect.right = txt_right
     w_rect.top = v.rsr_spc
     iron_amount = font.render(str(plr.r_iron), False, self.colors.white)
     i_rect = iron_amount.get_rect()
     i_rect.right = txt_right
     i_rect.top = h + v.rsr_spc
     fuel_amount = font.render(str(plr.r_fuel), False, self.colors.white)
     f_rect = fuel_amount.get_rect()
     f_rect.right = txt_right
     f_rect.top = 2*h + v.rsr_spc
     self.screen.blit(wood_amount, w_rect)
     self.screen.blit(iron_amount, i_rect)
     self.screen.blit(fuel_amount, f_rect)
Exemple #2
0
    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)
Exemple #3
0
 def render_fill(cls, text, font_info, surface):
     font = SysFont(font_info.name, font_info.size)        
     font.set_bold(font_info.bold)
     font.set_italic(font_info.italic)
     words = text.split()
     word_surfaces = []
     whitespace = font.render(" ", True, font_info.fcolor, font_info.bcolor)
     for word in words:
         word_surfaces.append(font.render(word, True, font_info.fcolor,
                                          font_info.bcolor))
     
     sf_width = surface.get_width()
     line = []
     line.free = sf_width
     lines = [line]
     max_height = max([surface.get_height() for surface in word_surfaces])
     cur_height = max_height
     for sf in word_surfaces:
         if lines[-1].free == sf_width:
             assert(sf_width < sf.get_width())
             lines[-1].append(sf)
             lines[-1].free -= sf.get_width()
         else:
             if sf.get_width() + whitespace.get_width() > lines[-1].free:
                 lines[-1].append(sf)
                 lines[-1].free -= sf.get_width() + whitespace.get_width() 
             else:
                 if (cur_height + (1 + font_info.spacing) * max_height < 
                     surface.get_width()):
                     assert(sf_width < sf.get_width())
                     line = []
     pass
Exemple #4
0
 def __init__(self, resourcemgr, team, level):
     super(InGame, self).__init__(resourcemgr)
     self.tilemgr = TileManager(resourcemgr, level)
     self.unitmgr = UnitManager(resourcemgr, STATES.INGAME, team, level)
     self.lw = self.tilemgr.lw
     self.lh = self.tilemgr.lh
     self.team = team
     # self.bar = Bar(config)
     music.load(os.path.join(resourcemgr.main_path, 'sound/yyz.ogg'))
     self.camera = Camera(0, 0, self.lw, self.lh, resourcemgr)
     font = SysFont(FONTS, int(48 * resourcemgr.scale), True)
     self.win_msg = font.render('YOU WINNN!!! GGGG GGGGGGGGGGGGGGG', 1,
         WHITE)
     self.win_msg_rect = self.win_msg.get_rect(
         centerx=self.camera.rect.w / 2, centery=self.camera.rect.h / 4)
     self.lose_msg = font.render('You lost. What the f**k, man?', 1,
         BLACK)
     self.lose_msg_rect = self.win_msg.get_rect(
         centerx=self.camera.rect.w / 2, centery=self.camera.rect.h / 4)
     self.mouse_rect = Rect(0, 0, 0, 0)
     self.x_first = 0
     self.y_first = 0
     self.won = False
     self.lost = False
     self.gg = load_sound(resourcemgr.main_path, 'gg.ogg')
     self.lose = load_sound(resourcemgr.main_path, 'lose.ogg')
Exemple #5
0
class Renderer:
    path = rootpath + '/GA/result/figure/'
    size = (1440, 192)

    def __init__(self, surface):
        self.surface = surface
        self.status = 0  # 0: auto; 1: manul
        self.iter = 0
        self.ftw = 120
        self.font = SysFont('Comic Sans MS', 32)
        self.draw_help()

    def on_space(self):
        if self.status == 0:
            self.status = 1
            self.ftw = 120
        else:
            self.status = 0

    def on_left(self):
        if self.status == 1 and self.iter > 0:
            self.iter -= 1

    def on_right(self):
        if self.status == 1 and self.iter < Renderer.get_file_num() - 1:
            self.iter += 1

    def draw_help(self):
        if self.status == 1:
            text_surface = self.font.render(
                'Iteration' + str(self.iter) + "(>>)", True, (0, 0, 0))
        else:
            text_surface = self.font.render(
                'Iteration' + str(self.iter) + "(||)", True, (0, 0, 0))

        self.surface.blit(text_surface, [0, 0])

    def draw_level(self):
        img = image.load(Renderer.path + 'iteration%d.jpg' % self.iter)
        img = transform.scale(img, Renderer.size)
        self.surface.blit(img, [0, 0])
        if self.status == 0:
            if self.ftw > 0:
                self.ftw -= 1
                return
            if self.iter < Renderer.get_file_num() - 1:
                self.iter += 1
                self.ftw += 120

    def update(self):
        self.draw_level()
        self.draw_help()

    @staticmethod
    def get_file_num():
        _, _, files = os.walk(Renderer.path).__next__()
        return len(files)
Exemple #6
0
class Scoreboard():
    def __init__(self, ai_setting, screen, stats):
        self.ai_setting = ai_setting
        self.stats = stats
        self.screen = screen
        self.screen_rect = screen.get_rect()
        self.text_color = (30, 30, 30)
        self.font = SysFont(None, 48)

        self.prep_score()
        self.prep_high_score()
        self.prep_level()
        self.prep_ships()

    def show_score(self):
        self.screen.blit(self.score_image, self.score_rect)
        self.screen.blit(self.high_score_image, self.high_score_rect)
        self.screen.blit(self.level_image, self.level_rect)
        self.ships.draw(self.screen)

    def prep_score(self):
        rounded_score = round(self.stats.score, -1)
        score_str = "{:,}".format(rounded_score)
        self.score_image = self.font.render(
            score_str, True, self.text_color, self.ai_setting.bg_color)
        self.score_rect = self.score_image.get_rect()
        self.score_rect.right = self.screen_rect.right - 20
        self.score_rect.top = 20

    def prep_high_score(self):
        high_score = int(round(self.stats.high_score, -1))
        high_score_str = "{:,}".format(high_score)
        self.high_score_image = self.font.render(
            high_score_str, True, self.text_color, self.ai_setting.bg_color)
        self.high_score_rect = self.high_score_image.get_rect()
        self.high_score_rect.centerx = self.screen_rect.centerx
        self.high_score_rect.top = 20

    def prep_level(self):
        self.level_image = self.font.render(
            str(self.stats.level), True, self.text_color, self.ai_setting.bg_color)
        self.level_rect = self.level_image.get_rect()
        self.level_rect.right = self.score_rect.right
        self.level_rect.top = self.score_rect.bottom + 10

    def prep_ships(self):
        self.ships = Group()
        for ship_number in range(self.stats.ships_left):
            ship = Ship(self.ai_setting, self.screen)
            ship.rect.x = 10 + ship_number * ship.rect.width
            ship.rect.y = 10
            self.ships.add(ship)
Exemple #7
0
 def text(self, text):
     self._text = text
     font = SysFont('consola', 60)
     self._font = font.render(self._text, True, (255, 0, 0))
     # well, figure out what the font's width is depended on
     self.content['font'] = [self._font,
                             (self.rect.centerx - self._font.get_width() / 2, self.rect.centery - self._font.get_height() / 2)]
Exemple #8
0
    def drawSummary(self, screen):
        """
        draws a summary
        """
        x = 30
        y = 50
        fontObj = SysFont("Monospace", 18, bold=True)

        time = 0
        rowHeight = fontObj.get_height() + 2

        for world in self.worlds:
            time = max(time, world.time)
            renderedFitness = fontObj.render("Fitness: {0:.2f}".format(world.nn.fitness), 1, (255, 255, 255))

            if (y + rowHeight > (constants.screenHeight - 95)):
                y = 50
                x += 260
                if x + renderedFitness.get_width() > constants.screenWidth:
                    break
                # draw vertical line
                pygame.draw.line(screen, (100, 100, 100), (x - 10, 45), (x - 10, constants.screenHeight - 100), 2)
            # draw horizontal line (if still on first column)
            elif x < 100:
                pygame.draw.line(screen, (100, 100, 100), (25, y + rowHeight - 3),
                                 (constants.screenWidth - 25, y + rowHeight - 3), 2)

            screen.blit(renderedFitness, (x, y))

            y += rowHeight

        # draw the time
        renderedTime = pygame.font.SysFont("Monospace", 34, bold=True).render("Time: {0:.2f}".format(time), 1,
                                                                              (255, 255, 255))
        screen.blit(renderedTime, ((constants.screenWidth - renderedTime.get_width()) // 2, 10))
Exemple #9
0
class Button:
    """A class that represents a button"""
    def __init__(self, game_set, screen, msg):
        """Starts the attributes of the button"""
        self.screen = screen
        self.screen_rect = screen.get_rect()

        #Define dimension and properties of the button
        self.width, self.height = 500, 50  #self.width, self.height = 200, 50 == self.width = 200
        #self.height = 50
        self.button_color = (0, 175, 0)
        self.text_color = (255, 255, 255)
        self.font = SysFont(None, 48)

        #Creating the rect object of the button and putting it in the center of the screen
        self.rect = pygame.Rect(0, 0, self.width, self.height)
        self.rect.center = self.screen_rect.center

        #The message must be prepared only once
        self.prep_msg(msg)

    def prep_msg(self, msg):
        """Transform the string in a image and centralize the text in the button"""
        #render() will create an image with the string
        self.msg_image = self.font.render(msg, True, self.text_color,
                                          self.button_color)
        self.msg_image_rect = self.msg_image.get_rect()
        self.msg_image_rect.center = self.rect.center

    def draw_button(self):
        """Draws a button in white, and following that, draws the message"""
        self.screen.fill(self.button_color, self.rect)
        self.screen.blit(self.msg_image, self.msg_image_rect)
Exemple #10
0
class Button(object):
    """游戏的开始按钮"""
    def __init__(self, ai_settings, screen, msg):
        self.screen = screen
        self.ai_settings = ai_settings
        self.screen_rect = self.screen.get_rect()
        # 设置按钮各种属性
        self.width, self.height = 100, 25
        self.button_color = (0, 250, 0)
        self.text_color = (255, 255, 255)
        self.text_font = SysFont(None, 24)
        # 画出按钮
        self.rect = pygame.Rect(0, 0, self.width, self.height)
        self.rect.center = self.screen_rect.center
        # 将按钮上的文字渲染为图片,并将其与按钮居中对齐
        self.text_image = self.text_font.render(msg, True, self.text_color, self.button_color)
        self.text_image_rect = self.text_image.get_rect()
        self.text_image_rect.center = self.rect.center

    def draw(self):
        """绘制"""
        # 绘制按钮外形
        self.screen.fill(self.button_color, self.rect)
        # 绘制被渲染过的文字图片
        self.screen.blit(self.text_image, self.text_image_rect)
Exemple #11
0
class Button:
    def __init__(self, screen, msg):

        """Инициализирует атрибуты кнопки."""
        self.screen = screen
        self.screen_rect = screen.get_rect()
        # Назначение размеров и свойств кнопок.
        self.width, self.height = 200, 50
        self.button_color = (100, 255, 100)
        self.text_color = (255, 255, 255)
        self.font = SysFont(None, 48)
        # Построение объекта rect кнопки и выравнивание по центру экрана.
        self.rect = pygame.Rect(0, 0, self.width, self.height)
        self.rect.center = self.screen_rect.center
        # Сообщение кнопки создается только один раз.
        self.prep_msg(msg)

    def prep_msg(self, msg):
        """Преобразует msg в прямоугольник и выравнивает текст по центру."""
        self.msg_image = self.font.render(msg, True, self.text_color,
                                          self.button_color)
        self.msg_image_rect = self.msg_image.get_rect()
        self.msg_image_rect.center = self.rect.center

    def draw_button(self):
        # Отображение пустой кнопки и вывод сообщения.
        self.screen.fill(self.button_color, self.rect)
        self.screen.blit(self.msg_image, self.msg_image_rect)
Exemple #12
0
 def text(self, value):
     self._text = value
     font = SysFont('consola', self.font_size)
     self._font = font.render(self._text, True, (255, 0, 0))
     self.content['font'] = [self._font, (
         self.rect.centerx - self._font.get_width() / 2,
         self.rect.centery - self._font.get_height() / 2)]
class Scoreboard():
    def __init__(self, game):
        self.settings = game.settings
        self.screen = game.screen
        self.stats = game.stats
        self.screen_rect = self.screen.get_rect()

        self.font = SysFont(None, 70)
        self.text_color = (255, 255, 255)
        self.score = self.stats.score
        self.best = 0

        self.prep_score()
        self.prep_time()

    def prep_score(self):
        rounded_score = round(self.stats.score, -1)
        score_str = "{:,}".format(rounded_score)
        self.image_score = self.font.render(score_str, True, self.text_color)
        self.score_rect = self.image_score.get_rect()
        self.score_rect.top = self.screen_rect.top + 20
        self.score_rect.right = self.screen_rect.right - 20

    def prep_time(self):
        format_time = "%02d:%02d" % (self.stats.minutes, self.stats.seconds)
        self.image_time = SysFont(None, 30).render(format_time, True,
                                                   (150, 150, 150))
        self.time_rect = self.image_time.get_rect()
        self.time_rect.topright = self.score_rect.bottomright
        self.time_rect.top += 10

    def blit_score(self):
        self.screen.blit(self.image_score, self.score_rect)
        self.screen.blit(self.image_time, self.time_rect)
def display_abacus_add_subtract_problem(
    screen,
    color,
    separator_bead_color,
    upper_left,
    height,
    operands,
    line_spacing=1.2,
    font=None,
):
    if font is None:
        font = SysFont('Lucida Console', height)
    x_ul, y_ul = upper_left
    max_digits = max(len(digitize(operand)) for operand in operands)
    column_width = height_to_width(height)
    max_sign_width = 0.

    for row_n, operand in enumerate(operands):
        x_row = x_ul
        y_row = y_ul + row_n * height * line_spacing

        digits = digitize(abs(operand))
        n_digits = len(digits)

        sign = '+' if operand >= 0 else '-'
        sign_surface = font.render(sign, True, color)
        sign_width = sign_surface.get_width()

        max_sign_width = max(sign_width, max_sign_width)

        screen.blit(sign_surface, (x_row, y_row))

        draw_columns(
            screen,
            color,
            (x_row + sign_width +
             (max_digits - n_digits) * column_width, y_row),
            height,
            digits,
            separator_bead_color=separator_bead_color,
        )

    row_n = len(operands)
    x_rect_left = x_ul
    x_rect_right = (x_ul + max_sign_width + max_digits * column_width)
    y_rect_top = (y_ul + height * (row_n * line_spacing - .25 *
                                   (line_spacing - 1.)))
    y_rect_bottom = (y_rect_top + .25 * (line_spacing - 1.) * height)

    polygon(screen, color, [
        (x_rect_left, y_rect_top),
        (x_rect_right, y_rect_top),
        (x_rect_right, y_rect_bottom),
        (x_rect_left, y_rect_bottom),
    ])

    # coordinates of where to draw the rightmost digit
    # of the response
    return ((x_ul + sign_width + max_digits * column_width),
            y_ul + row_n * height * line_spacing)
class Button():
    def __init__(self, ai_setting, screen, msg):
        self.screen = screen
        self.screen_rect = screen.get_rect()

        self.width = 200
        self.height = 50
        self.button_color = (0, 255, 0)
        self.text_color = (255, 255, 255)
        self.font = SysFont(None, 48)

        self.rect = pygame.Rect(0, 0, self.width, self.height)
        self.rect.center = self.screen_rect.center

        self.prep_msg(msg)

    def prep_msg(self, msg):
        self.msg_image = self.font.render(
            msg, True, self.text_color, self.button_color)
        self.msg_image_rect = self.msg_image.get_rect()
        self.msg_image_rect.center = self.rect.center

    def draw_button(self):
        self.screen.fill(self.button_color, self.rect)
        self.screen.blit(self.msg_image, self.msg_image_rect)
Exemple #16
0
    def show(self):
        screen = display.get_surface()
        draw.rect(screen, self._color,
                  (self._x, self._y, self._width, self._height))

        if not self.__controller.stopped:

            cell_x = self._x
            cell_y = self._y

            for line in self.__model.data:
                for cell in line:
                    if cell == 1:
                        draw.rect(screen, self.__living_cell_color,
                                  (cell_x, cell_y, self.__cell_size,
                                   self.__cell_size))
                    cell_x = cell_x + self.__cell_size
                cell_y = cell_y + self.__cell_size
                cell_x = self._x

            for child in self._children:
                child.show()
        else:
            font = SysFont('', 60)

            current_strategy_text = self.__current_strategy_text + self.__controller.strategy

            welcome_text = font.render(self.__welcome_message, True,
                                       PG_COLORS.get('white'))
            current_strategy = font.render(current_strategy_text, True,
                                           PG_COLORS.get('white'))
            instruction_text = font.render(self.__instruction_text, True,
                                           PG_COLORS.get('white'))

            text_width, text_height = font.size(self.__welcome_message)
            cs_text_width, cs_text_height = font.size(current_strategy_text)
            i_text_width, i_text_height = font.size(self.__instruction_text)

            screen.blit(welcome_text,
                        (self._x + self._width / 2 - text_width / 2,
                         self._y + self._height / 2 - text_height * 2.5))
            screen.blit(instruction_text,
                        (self._x + self._width / 2 - i_text_width / 2,
                         self._y + self._height / 2 - text_height))
            screen.blit(current_strategy,
                        (self._x + self._width / 2 - cs_text_width / 2,
                         self._y + self._height / 2 + text_height / 2))
Exemple #17
0
 def __init__(self, resourcemgr):
     super(Intro, self).__init__(resourcemgr)
     self.bg = resourcemgr.get_background_image(BACKGROUNDS.INTRO)
     self.bg_rect = self.bg.get_rect()
     font = SysFont(FONTS, int(52 * self.resourcemgr.scale), True)
     self.msg = font.render('Sprayed Studios Presents...', 1, RED)
     self.msg_rect = self.msg.get_rect(centerx=self.bg_rect.w / 2,
         centery=self.bg_rect.h / 10)
Exemple #18
0
class Text(Component):
    def __init__(self,
                 container,
                 text="",
                 fontType="",
                 x=0,
                 y=0,
                 textSize=0,
                 color=COLORS.WHITE,
                 onActivate=None):
        self.text = text
        self.textSize = textSize
        self.color = color
        self.font = SysFont(fontType, self.textSize)
        self.size = self.font.size(self.text)
        self.surface = self.font.render(self.text, True, self.color)
        super().__init__(container,
                         x,
                         y,
                         self.size,
                         surface=self.surface,
                         onActivate=onActivate)

    def setColor(self, color):
        color = [a if a < 255 else 255 for a in color]
        color = [a if a > 0 else 0 for a in color]
        self.color = color
        self.update()

    def setText(self, text):
        self.text = text
        self.update()

    def getText(self):
        return self.text

    def update(self):
        self.surface = self.font.render(self.text, True, self.color)
        self.rect = self.surface.get_rect()

    def select(self):
        self.setColor(COLORS.GREY)

    def unSelect(self):
        self.setColor(COLORS.BLACK)
Exemple #19
0
 def blit_loading(self):
     clrs = self.colors
     v = self.ui_vars
     font = Font(self.CORE.font_family, self.CORE.fonts['loading'][0])
     text = font.render(self.TEXT.loading, False, clrs.white)
     rect = text.get_rect()
     rect.centerx = v.disp_cx
     rect.centery = v.disp_cy
     self.screen.fill(clrs.gdark)
     self.screen.blit(text, rect)
Exemple #20
0
class Hud(object):
    def __init__(self):
        self.hud = Surface((65, 70), SRCALPHA, 32)
        self.font = SysFont('Arial', 14)

    def draw(self, character, screen):
        self._clear()
        hp = character.hp.value
        ac = character.ac.get_value()
        xp = character.get_xp()
        hp_surface = self.font.render('HP: ' + str(hp), False, Color(255, 255, 255))
        ac_surface = self.font.render('AC: ' + str(ac), False, Color(255, 255, 255))
        xp_surface = self.font.render('XP: ' + str(xp), False, Color(255, 255, 255))
        self.hud.blit(hp_surface, (10, 5))
        self.hud.blit(ac_surface, (10, 25))
        self.hud.blit(xp_surface, (10, 45))
        screen.blit(self.hud, (950, 10))

    def _clear(self):
        self.hud.fill(Color(255, 255, 0, 50))
 def generateNewTextImage(self) -> NoReturn:
     from Mangers.graph_manager import DimensionsManger
     diments = DimensionsManger()
     fontInit()
     font = SysFont(get_default_font(), diments.VerticesDiments.fontSize)
     keyImage = font.render(str(self.name), True,
                            Colors.VerticesColors.OnVertexDefaultColor)
     wText, hText = font.size(str(self.name))
     self.wTextHalf, self.hTextHalf = wText // 2, hText // 2
     self.textImage = keyImage
     self.isMoved = True
Exemple #22
0
def T(cw, txt, x, y, r=0, g=0, b=0, aliasing=1, size=20, center=True):
    """allows the display of text on screen with or without centering
	the text will be displayed in the window 'cw'
	"""
    font = SysFont(None, size)
    text = font.render(txt, aliasing, (r, g, b))
    if center:
        textpos = text.get_rect(centery=y, centerx=x)
    else:
        textpos = (x, y)
    cw.blit(text, textpos)
Exemple #23
0
class MyText(object):
    #传入screen以访问主屏幕
    def __init__(self,screen,text_start_point=define.TEXT_START_POINT,font=define.TEXT_FONT,font_size=define.FONT_SIZE,):
        try:
            self.font = Font(font,font_size)
        except IOError:
            print "bad font file name or i/o error,sys will load default font"
            self.font = SysFont("simsunnsimsun",font_size,False,False)
        self.screen = screen
        self.text_start_point = text_start_point
    def get_text(self,text_content=""):
        #接受原始文字数据
        self.text_content = text_content
        
    #字体显示,一次仅显示一行,通过多次显示来完成显示
    def text_display(self,text_color=(0,0,0)):
        line_height = self.font.get_linesize()
        char_per_line = define.TEXT_SCREEN_SIZE[0]/line_height
        text_length = len(self.text_content)
        #print char_per_line,line_height,len(self.text_content)
        y = self.text_start_point[1]
        range_times = text_length/char_per_line
        #绘制文字背景
        text_bg = pygame.image.load('ui/window.png').convert_alpha()
        self.screen.blit(text_bg,define.TEXT_WINDOW_POINT)
        #绘制文字
        for i in xrange(range_times+1):
            #用切片保证文字正确换行
            txt_in_line = self.text_content[i*char_per_line:(i+1)*char_per_line]
            if  txt_in_line == "": 
                break
            self.screen.blit(self.font.render(txt_in_line,True,text_color),(self.text_start_point[0],y))
            y += line_height
    def selection_display(self,select_order,text_color=(0,0,0)):
        line_height = self.font.get_linesize()
        #这里的select_order从0开始,这个方法的目的在于绘制选项文字,为button类对象提供一个简单的文字绘制方法
        self.screen.blit(self.font.render(self.text_content,True,text_color),(self.text_start_point[0],self.text_start_point[1]+line_height*select_order))
    def display_by_speed(self,display_speed):
        #字体显示速度,用字的数量计,单位“字/0,1秒”
        self.speed = display_speed
        pass
    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)
Exemple #25
0
    def __init__(self, resourcemgr):
        super(Menu, self).__init__(resourcemgr)
        self.bg = resourcemgr.get_background_image(BACKGROUNDS.MAIN_MENU)
        self.bg_rect = self.bg.get_rect()
        font = SysFont(FONTS, int(48 * self.resourcemgr.scale), True)
        self.msg = font.render('RTS TEST 3000XX', 1, WHITE)
        self.msg_rect = self.msg.get_rect(centerx=self.bg_rect.w / 2,
            centery=self.bg_rect.h / 6)

        self.start = Button((self.bg_rect.w - 100) / 2,
            self.bg_rect.h * (7 / 10.0), BUTTONS.START, resourcemgr)
        self.edit = Button((self.bg_rect.w - 100) / 2,
            self.bg_rect.h * (4 / 5.0), BUTTONS.EDIT, resourcemgr)
Exemple #26
0
 def blit_cns_selection(self):
     v = self.ui_vars
     font = Font(self.CORE.font_family, self.CORE.fonts['obj_name'][0])
     of_x, of_y = v.csel_ofx, v.csel_ofy
     cntr_w = v.disp_w - 2*v.cns_ss
     text = ''
     # Selection attrs / list
     if len(self.selection) == 1:
         text = self.TEXT.objects[self.selection[0].objkey]
         if self.debug:
             text += self.selection[0].get_address()
         index = 0
         for key, value in self.selection[0].get_attrs().items():
             icon = self.gfx.icons[key]
             vtext = font.render(str(value), False, self.colors.white)
             y = of_y + index*(v.cicos+v.cspc)
             self.screen.blit(icon, (of_x, y))
             self.screen.blit(vtext,  (of_x+v.cicos+v.cspc, y))
             index += 1
     elif len(self.selection) > 1:
         text = str(len(self.selection))+self.TEXT.obj_count_suffix
         sect_w = v.csel_cols*(v.cicos+v.csel_spc)-v.csel_spc
         i = 0
         for obj in self.selection:
             texture = self.gfx.grayed[obj.objkey]
             x = (i% v.csel_cols) * (v.cicos+v.csel_spc)
             y = (i//v.csel_cols) * (v.cicos+v.csel_spc)
             x = x + cntr_w//2 + v.cns_ss - sect_w//2
             y = y + v.disp_h - v.cns_ch + 2*v.csel_spc + v.csel_th
             self.screen.blit(texture, (x,y))
             i += 1
             if i > v.csel_cols * v.csel_rows:
                 break
     # Selection main text
     text = font.render(text, False, self.colors.white)
     crect = text.get_rect()
     crect.top = v.disp_h - v.cns_ch
     crect.centerx = cntr_w//2 + v.cns_ss
     self.screen.blit(text, crect)
Exemple #27
0
class Label(Node):
    def __init__(self, text,
                 relative_x=0,
                 relative_y=0,
                 font_color=DEFAULT_FONT_COLOR,
                 font_name=DEFAULT_FONT_NAME,
                 font_size=DEFAULT_FONT_SIZE,
                 ):
        super().__init__(relative_x, relative_y)
        self.text = text
        self.font_color = font_color
        self.font_name = font_name
        self.font_size = font_size
        self.font = SysFont(self.font_name, self.font_size)
        self.surface = self.font.render(self.text, True, self.font_color)

    def update(self):
        super().update()
        self.font = SysFont(self.font_name, self.font_size)
        self.surface = self.font.render(self.text, True, self.font_color)

    def draw(self, screen):
        screen.blit(self.surface, (self.x, self.y))

    def get_width(self):
        return self.surface.get_width()

    def get_height(self):
        return self.surface.get_height()

    def is_colliding(self, pos):
        return pos[0] in range(
            self.x,
            self.x + self.get_width()
        ) and pos[1] in range(
            self.y,
            self.x + self.get_height()
        )
Exemple #28
0
 def __init__(self,
              text,
              position,
              next_scene,
              clicked_event=USEREVENT,
              *groups):
     super(Button, self).__init__(*groups)
     font = SysFont('tahoma', 32)
     self.name = text
     self.image = font.render(text, True, (255, 255, 255))
     self.rect = self.image.get_rect()
     self.rect.center = position
     self.event = clicked_event
     self.next_scene = next_scene
Exemple #29
0
 def render_column(cls, lines, font_info, surface):
     font = SysFont(font_info.name, font_info.size)        
     font.set_bold(font_info.bold)
     font.set_italic(font_info.italic)
     line_surfaces = []
     for line in lines:
         line_surfaces.append(font.render(line, True, font_info.fcolor,
                                          font_info.bcolor))
     max_height = max([sf.get_height() for sf in line_surfaces])
     spacing = ((surface.get_height() - max_height * len(lines))
                 / (len(lines) + 1))
     for sf, y in zip(line_surfaces,
             range(spacing, surface.get_height(), spacing + max_height)):
         surface.blit(sf, (0, y))
Exemple #30
0
class Debug:
    surface: Surface
    tps: TimeTracker
    font: Font

    def __init__(self) -> None:
        self.tps = TimeTracker(perf_counter_ns)
        pass

    def set_surface(self, surface: Surface) -> None:
        self.font = SysFont(None, 25)
        self.surface = surface

    def draw_tps(self) -> None:
        image = self.font.render("TPS: " + str(self.tps.fps()), True,
                                 (255, 255, 255))
        self.surface.blit(image, image.get_rect())
        self.tps.tick()
Exemple #31
0
def draw_text(surface, color, text, position, size, anchor=''):
    global font
    # if font is None or size > 256:
    font = SysFont('consolas', size * 3 // 4)
    textobj = font.render(text, 1, color)
    textrect = textobj.get_rect()
    if anchor == 'bottomleft':
        textrect.bottomleft = position
    elif anchor == 'topleft':
        textrect.topleft = position
    elif anchor == 'bottomright':
        textrect.bottomright = position
    elif anchor == 'topright':
        textrect.topright = position
    else:
        textrect.center = position
    surface.blit(textobj, textrect)
    return textrect
Exemple #32
0
class Widget:
    def __init__(self, **kwargs):
        self.rect = Rect(kwargs.get('x', 0), kwargs.get('y', 0),
                         kwargs.get('width', 200), kwargs.get('height', 50))
        self.image = Surface((self.rect.width, self.rect.height))
        self.background_image = kwargs.get('background_image', 0)
        self.background_image_pos = kwargs.get('background_image_pos', (0, 0))
        self.background_color = kwargs.get('background_color', (32, 32, 32))
        self.background_color_cover = kwargs.get('background_color_cover',
                                                 self.background_color)
        self.background_color_click = kwargs.get('background_color_click',
                                                 self.background_color)
        self.text = kwargs.get('text', '')
        self.font_size = kwargs.get('font_size', 20)
        self.font_color = kwargs.get('font_color', (255, 255, 255))
        self.font_pos = kwargs.get('font_pos', None)
        self.font = SysFont('segoeui', self.font_size, 1)
        self.image.fill(self.background_color)
        self.onclick = kwargs.get('onclick', lambda: None)

    def show(self, surface):
        if self.background_image:
            self.image.blit(self.background_image, self.background_image_pos)
        font = self.font.render(self.text, 1, self.font_color)
        pos = self.font_pos or [
            (self.rect.width - font.get_rect().width) // 2,
            (self.rect.height - font.get_rect().height) // 2
        ]
        self.image.blit(font, pos)
        surface.blit(self.image, (self.rect.x, self.rect.y))

    def _onclick(self):
        self.onclick()

    def update(self, events):
        if self.rect.collidepoint(*get_mouse_pos()) and get_mouse_pressed()[0]:
            self.image.fill(self.background_color_click)
        elif self.rect.collidepoint(*get_mouse_pos()):
            self.image.fill(self.background_color_cover)
            for event in events:
                if event.type == MOUSEBUTTONUP:
                    self._onclick()
        else:
            self.image.fill(self.background_color)
Exemple #33
0
class Statusbar(Sprite):

	padding				= 8
	font				= 'Ubuntu Light'
	font_size			= 22
	foreground_color	= (250,250,160)
	background_color	= (0,0,12)


	def __init__(self):
		Sprite.__init__(self, Game.current.sprites)
		Game.current.sprites.change_layer(self, Game.LAYER_ABOVE_BG)
		self.font = SysFont(self.font, 22)
		self.image = Surface((
			Game.current.board.rect.width,
			self.font.get_linesize() + self.padding * 2
		))
		self.text = ""
		self.rect = self.image.get_rect()


	def clear(self):
		self.image.fill(self.background_color)


	def write(self, text, color=None):
		self.text = text
		if color is not None: self.foreground_color = color
		self._update()


	def append(self, text):
		self.text = self.text + text
		self._update()


	def _update(self):
		self.clear()
		self.image.blit(
			self.font.render(self.text, True, self.foreground_color),
			(self.padding, self.padding)
		)
Exemple #34
0
class ScoreBoard(object):
    """几分面板类"""
    def __init__(self, ai_settings, game_status, screen):
        self.ai_settings = ai_settings
        self.game_stats = game_status
        self.screen = screen
        self.screen_rect = self.screen.get_rect()
        self.text_font = SysFont(None, 18)
        self.text_color = (120, 30, 30)


    def pre_socre(self):
        self.text_img = self.text_font.render(str(self.game_stats.score), True, self.text_color, self.ai_settings.bg_color)
        self.text_img_rect = self.text_img.get_rect()
        self.text_img_rect.right = self.screen_rect.right - 10
        self.text_img_rect.top = 5

    def blitme(self):
        self.pre_socre()
        self.screen.blit(self.text_img, self.text_img_rect)
Exemple #35
0
def change_state(next_state, resourcemgr):
    resourcemgr.screen.fill(BLACK)
    font = SysFont(FONTS, int(48 * resourcemgr.scale), True)
    text = font.render('Loading...', 1, WHITE)
    textpos = text.get_rect(centerx=resourcemgr.screen.get_width() / 2,
        centery=resourcemgr.screen.get_height() / 4)
    resourcemgr.screen.blit(text, textpos)
    pygame.display.flip()

    current_state = None
    if next_state == STATES.INTRO:
        current_state = Intro(resourcemgr)
    elif next_state == STATES.MENU:
        current_state = Menu(resourcemgr)
    elif next_state == STATES.INGAME:
        current_state = InGame(resourcemgr, 0,
            os.path.join(resourcemgr.main_path, 'scenarios/test.ics'))
    elif next_state == STATES.EDITOR:
        current_state = Editor(resourcemgr)

    return current_state
Exemple #36
0
 def display(self, g):
     g.win().blit(self.background,
                  (self.x - self.offsetX, self.y - self.offsetY))
     g.win().blit(self.talker.pic,
                  (self.x - self.offsetX, self.y - self.offsetY))
     w = self.talker.pic.get_width()
     x_text, y_text = self.x + w + 10, self.y + 5
     font = SysFont("arial_unicode_ms", 40)
     words = [line.split(" ") for line in self.msg.splitlines()]
     space = font.size(' ')[0]
     for line in words:
         for word in line:
             word_surface = font.render(word, 1, (0, 0, 0))
             word_width, word_height = word_surface.get_size()
             if x_text + word_width + self.offsetX >= self.background.get_width(
             ) + self.x:
                 x_text = self.x + w + 10  # Reset the x.
                 y_text += word_height  # Start on new row.
             g.win().blit(word_surface, (x_text, y_text))
             x_text += word_width + space
         x_text = self.x + w + 10  # Reset the x.
         y_text += word_height  # Start on new row.
Exemple #37
0
class Button:
    """ A button at the center of the screen """
    def __init__(self, settings: Settings, screen: Surface, msg):
        self._screen = screen
        self._settings = settings

        self._width, self._height = settings.btn_size
        self._font = SysFont(None, settings.btn_font_size)

        self.rect = Rect(0, 0, self._width, self._height)
        self.rect.center = screen.get_rect().center

        self._render_msg(msg)

    def _render_msg(self, msg):
        self._msg_image = self._font.render(msg, True,
                                            self._settings.btn_txt_color)
        self._msg_image_rect = self._msg_image.get_rect()
        self._msg_image_rect.center = self.rect.center

    def draw(self):
        self._screen.fill(self._settings.btn_color, self.rect)
        self._screen.blit(self._msg_image, self._msg_image_rect)
Exemple #38
0
class Console(object):
    def __init__(self):
        self.console = Surface((600, 85), SRCALPHA, 32)
        self._clear_log()
        font.init()
        self.font = SysFont('Arial', 14)
        self.messages = []

    def log(self, message):
        self.messages.append(message)

    def draw(self, screen):
        msgs = self.messages[-4:len(self.messages)]
        msgs.reverse()
        self._clear_log()
        i = 65
        for msg in msgs:
            text_surface = self.font.render(msg, False, Color(255, 255, 255))
            self.console.blit(text_surface, (10, i))
            i -= 20
        screen.blit(self.console, (20, 670))

    def _clear_log(self):
        self.console.fill(Color(255, 255, 255, 50))
Exemple #39
0
class Window:
    # A Window represents a display window with a title bar,
    # close box and interior drawing surface.

    def __init__(self, title, width, height):
        # Create and open a window to draw in.
        # - self is the new Window
        # - title is the str title of the window
        # - width is the int pixel width of the window
        # - height is the int pixel height of the window

        init()
        self.__surface__ = set_mode((width, height), 0, 0)
        set_caption(title)
        self.__font_name__ = ''
        self.__font_size__ = 18
        self.__font__ = SysFont(self.__font_name__, self.__font_size__, True)
        self.__font_color__ = 'white'
        self.__bg_color__ = 'black'
        self.__auto_update__ = True

        try:
            self.stream = Stream()
            self.stream.start()
        except:
            pass

    def close(self):
        # Close the window
        # - self is the Window
        self.stream.stop()
        quit()

    def set_font_name(self, name):
        # Set the name of the window font used to draw strings
        # - self is the Window
        # - name is the str name of the font

        self.__font_name__ = name
        self.__font__ = SysFont(self.__font_name__, self.__font_size__, True)

    def set_font_size(self, point_size):
        # Set the point size of the window font used to draw strings
        # - self is the Window
        # - point_size is the int point size of the font

        self.__font_size__ = point_size
        self.__font__ = SysFont(self.__font_name__, self.__font_size__, True)

    def set_font_color(self, color_string):
        # Set the font color used to draw in the window
        # - self is the Window
        # - color_string is the str name of the font color

        self.__font_color__ = color_string

    def set_bg_color(self, color_string):
        # Set the background color used to draw in the window
        # - self is the Window
        # - color_string is the str name of the background color

        self.__bg_color__ = color_string

    def set_auto_update(self, true_false):
        # Set the background color used to draw in the window
        # - self is the Window
        # - true_or_false is a Boolean indicating if auto update should be on or off

        self.__auto_update__ = true_false

    def get_font_height(self):
        # Return the int pixel height of the current font.
        # - self is the Window

        return self.__font__.size('')[1]

    def get_font_color(self):
        # Return a str that represents the current window
        # font color
        # - self is the Window

        return self.__font_color__

    def get_bg_color(self):
        # Return a str that represents the current window
        # background color
        # - self is the Window

        return self.__bg_color__

    def set_bg_image(self, image_png, width, height):
        image = pygame.image.load(image_png)
        image = pygame.transform.scale(image,
                                       (self.get_width(), self.get_height()))
        self.__surface__.blit(image, [0, 0])

    def get_width(self):
        # Return the int pixel width of the window's drawable
        # interior surface
        # - self is the Window

        return self.__surface__.get_width()

    def get_height(self):
        # Return the int pixel height of the window's drawable
        # interior surface
        # - self is the Window

        return self.__surface__.get_height()

    def clear(self):
        # Erase the window contents
        # - self is the Window

        if self.__auto_update__:
            update()

    def get_surface(self):
        # Return the Pygame.Surface object that represents the
        # interior drawing surface of the window
        # - self is the Window

        return self.__surface__

    def draw_string(self, string, x, y, bg):
        # Draw a string in the window using the current font and
        # colors
        # - self is the Window
        # - string is the str object to draw
        # - x is the int x coord of the upper left corner of the
        #   string in the window
        # - y is the int y coord of the upper left corner of the
        #   string in the window

        text_image = self.__font__.render(string, True,
                                          Color(self.__font_color__), bg)
        self.__surface__.blit(text_image, (x, y))
        if self.__auto_update__:
            text_rect = Rect((x, y), text_image.get_size())
            update(text_rect)

    def input_string(self, prompt, x, y):
        # Draw a prompt string in the window using the current font
        # and colors. Check keys pressed by the user until an enter
        # key is pressed and return the sequence of key presses as a
        # str object.
        # - self is the Window
        # - prompt is the str to display
        # - x is the int x coord of the upper left corner of the
        #   string in the window
        # - y is the int y coord of the upper left corner of the
        #   string in the window

        key = K_SPACE
        answer = ''
        while key != K_RETURN:
            self.draw_string(prompt + answer + '    ', x, y)
            if not self.__auto_update__:
                update()
            key = self._get_key()
            key_state = get_pressed()
            if (K_SPACE <= key <= K_z):
                if key == K_SPACE:
                    letter = ' '
                else:
                    letter = name(key)
                if key_state[K_LSHIFT] or key_state[K_RSHIFT] or key_state[
                        K_CAPSLOCK]:
                    letter = letter.upper()
                answer = answer + letter
            if key == K_BACKSPACE:
                answer = answer[0:len(answer) - 1]
        return answer

    def get_string_width(self, string):
        # Return the int pixel width of the string using the current
        # font.
        # - self is the Window
        # - string is the str object

        return self.__font__.size(string)[0]

    def update(self):
        # Update the window by copying all drawn objects from the
        # frame buffer to the display.
        # - self is the Window

        update()

    def _get_key(self):
        # Poll the events until the user presses a key and return it.
        # Discard all other events.
        # - self is the Window

        event = poll()
        while event.type != KEYUP:
            event = poll()
        return event.key
Exemple #40
0
class Game(object):

    SCREEN_SIZE = (800, 600)
    FPS = 10
    FONT = get_default_font()

    def __init__(self):
        self._initPygame()
        self.snake_group = pygame.sprite.Group()
        self.block_group = pygame.sprite.Group()
        self.clock = pygame.time.Clock()
        self.snake = Snake(self.snake_group)
        self.block = Block(Game.SCREEN_SIZE, self.block_group)
        self.game_over = False
        self.score = 0

    def _initPygame(self):
        pygame.init()
        self.screen = pygame.display.set_mode(Game.SCREEN_SIZE)
        pygame.display.set_caption('Snake Game')
        self.game_font = SysFont(Game.FONT, 72)
        self.new_game_font = SysFont(Game.FONT, 48)
        self.score_font = SysFont(Game.FONT, 32)

    def newGame(self):
        self.snake_group.empty()
        self.block_group.empty()
        self.block = Block(Game.SCREEN_SIZE, self.block_group)
        self.snake = Snake(self.snake_group)
        self.game_over = False

    def render(self):
        self.snake.draw()
        self.screen.fill(BLACK)
        self.snake_group.draw(self.screen)
        self.block_group.draw(self.screen)
        self.displayScore()

    def displayScore(self):
        score_text = self.score_font.render("Score: %d" % self.score, 1, WHITE)
        self.screen.blit(score_text, (0, 0))

    def handleInput(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit(0)
            pressed_key = pygame.key.get_pressed()
            if pressed_key[K_LEFT]:
                self.snake.left()
            if pressed_key[K_RIGHT]:
                self.snake.right()
            if pressed_key[K_UP]:
                self.snake.up()
            if pressed_key[K_DOWN]:
                self.snake.down()

    def gameOver(self):
        self.score = 0
        game_over_text = self.game_font.render('Game Over', 1, RED)
        new_game_text = self.new_game_font.render(
            'Press Enter to new game', 1, RED)
        self.screen.blit(game_over_text, (250, 250))
        self.screen.blit(new_game_text, (200, 300))
        pressed_key = pygame.key.get_pressed()
        if pressed_key[K_RETURN]:
            self.newGame()

    def run(self):
        while True:
            self.handleInput()
            if any([self.snake.collidesItSelf(), self.snake.outOfTheScreen()]):
                self.gameOver()
            else:
                if self.snake.collidesWithBlock(self.block):
                    self.score += 10
                    self.block.group.remove(self.block)
                    self.block = Block(Game.SCREEN_SIZE, self.block_group)
                self.render()
            pygame.display.flip()
            self.clock.tick(Game.FPS)
Exemple #41
0
class Editor(State):
    def __init__(self, resourcemgr, level=None):
        super(Editor, self).__init__(resourcemgr)
        self.tilemgr = TileManager(resourcemgr, level)
        self.lw = self.tilemgr.lw
        self.lh = self.tilemgr.lh
        self.camera = Camera(0, 0, self.lw, self.lh, resourcemgr)
        self.current_tile = 0
        self.font = SysFont(FONTS, int(48 * self.resourcemgr.scale), True)

    def set_tile(self):
        x, y = mouse.get_pos()
        x += self.camera.rect.x
        y += self.camera.rect.y

        for t in self.tilemgr.tiles:
            if t.rect.collidepoint(x, y):
                t.set_tile(self.current_tile)
                break

    def get_tile(self):
        x, y = mouse.get_pos()
        x += self.camera.rect.x
        y += self.camera.rect.y

        for t in self.tilemgr.tiles:
            if t.rect.collidepoint(x, y):
                self.current_tile = t.kind
                break

    def render_kind(self):
        text = "Current Tile: %s" % self.tilemgr.tile_labels[self.current_tile]
        msg = self.font.render(text, 1, WHITE)
        msg_rect = msg.get_rect(
            centerx=self.resourcemgr.screen.get_rect().w / 2, centery=self.resourcemgr.screen.get_rect().h / 6
        )
        self.resourcemgr.screen.blit(msg, msg_rect)

    def input(self, event, next_state):
        next_state = super(Editor, self).input(event, next_state)

        self.camera.input(event)

        if event.type == KEYDOWN:
            if event.key == K_ESCAPE:
                self.tilemgr.save_tiles("map1.map")
                next_state = set_next_state(next_state, STATES.MENU)
        elif event.type == MOUSEBUTTONDOWN:
            if event.button == MOUSE.LEFT:
                self.set_tile()
            elif event.button == MOUSE.RIGHT:
                self.get_tile()
            elif event.button == MOUSE.WHEELUP:
                self.current_tile -= 1
                if self.current_tile < 0:
                    self.current_tile = self.tilemgr.total_tile_kinds - 1
            elif event.button == MOUSE.WHEELDOWN:
                self.current_tile += 1
                if self.current_tile > self.tilemgr.total_tile_kinds - 1:
                    self.current_tile = 0
        elif event.type == MOUSEMOTION and mouse.get_pressed()[0]:
            self.set_tile()

        return next_state

    def logic(self, clock, next_state):
        self.camera.logic(clock.get_time())
        return next_state

    def render(self):
        self.resourcemgr.screen.fill(BLACK)
        self.tilemgr.render(self.camera)
        self.render_kind()