Skip to main content
 首页 » 编程设计

使用它的两个实例时出现 Python_textinput 问题

2024年12月31日9mq0036

我正在使用 python 开发一款基于选择的冒险游戏,我正在使用 pygame 为游戏创建一些图形。

当我尝试创建一个屏幕以便玩家可以输入他的真实姓名和主要角色名称时,我遇到了一个问题:当我尝试在同一屏幕上创建两个文本输入(使用 pygame_textinput module )时,它只是克隆我在其中一个中写的内容。

我以为我可以通过将另一个输入放在新屏幕上来解决这个问题,但是当我在第一个屏幕上按下回车键时,它只是通过了其余代码,而第二个输入保持为空。

我该如何解决这个问题?

#Imports 
import contextlib 
with contextlib.redirect_stdout(None): 
    import pygame 
import pickle 
import time 
import random 
import pygame_textinput.pygame_textinput as textinput 
 
#Really messy, I know# 
 
#Save Stuff 
Choices = {} 
 
def save(to_save, save_filepath): 
    pickle.dump(to_save, open(save_filepath, "wb")) 
 
def load(save_filepath): 
    return pickle.load(open(save_filepath, "rb")) 
 
#Initializations 
pygame.init() 
 
#Screen 
scrWidth = 640 
scrHeight = 480 
screen = pygame.display.set_mode((scrWidth, scrHeight)) 
pygame.display.set_caption('Something') 
 
#Images 
startscreenbg = pygame.image.load('assets/Images/startscreen.jpg').convert() 
 
#Text Input 
real_nametxtinput = textinput.TextInput(text_color=(255,255,255)) 
char_nametxtinput = textinput.TextInput(text_color=(255,255,255)) 
 
#Clock 
clock = pygame.time.Clock() 
 
#Game Constants 
next = False 
real_name = '' 
char_name = '' 
real_name_done = False 
char_name_done = False 
 
##### Global Functions ##### 
 
#Buttons stuff 
buttonTextFont = pygame.font.SysFont("comicsansms", 20) 
def createButton(msg, msgcolor,x,y,width,height,color1,color2,action=None): 
    mouse = pygame.mouse.get_pos() 
    click = pygame.mouse.get_pressed() 
    if x+width > mouse[0] > x and y+height > mouse[1] > y: 
        pygame.draw.rect(screen, color2,(x,y,width,height)) 
 
        if click[0] == 1 and action != None: 
            action() 
    else: 
        pygame.draw.rect(screen, color1,(x,y,width,height)) 
 
    buttontext = buttonTextFont.render(msg, 1, msgcolor) 
    screen.blit(buttontext, (x + (width//2) - (buttontext.get_width()//2), (y + (height//2) - (buttontext.get_height()//2)))) 
 
 
 
##### Screens/Chapters ##### 
def update_next1(): 
    global next 
    next = True 
 
def start_screen(): 
    screen.blit(startscreenbg, (0, 0)) 
    new_game = createButton('New Game',(255,255,255), 80, 100, 200, 50, (0,180,0), (0,255,0), update_next1) 
    load_game = createButton('Load Game', (255,255,255), 360, 100, 200, 50, (0,0,180), (0,0,255)) 
 
#Names 
def real_name_screen(): 
    global real_name, real_name_done 
    screen.blit(startscreenbg, (0,0)) 
    pygame.draw.rect(screen, (102, 255, 102), (150, 90, 200, 50)) 
    screen.blit(real_nametxtinput.get_surface(), (150,100)) 
    if real_nametxtinput.update(events): 
        real_name = real_nametxtinput.get_text() 
        real_name_done = True 
 
 
def char_name_screen(): 
    global char_name, char_name_done 
    screen.blit(startscreenbg, (0, 0)) 
    pygame.draw.rect(screen, (255, 102, 255), (150, 90, 200, 50)) 
    screen.blit(char_nametxtinput.get_surface(), (150, 100)) 
    if char_nametxtinput.update(events): 
        char_name = char_nametxtinput.get_text() 
        if char_name != '': 
            char_name_done = True 
 
 
 
run = True 
while run: 
 
    clock.tick(27) 
 
    events = pygame.event.get() 
    for event in events: 
        if event.type == pygame.QUIT: 
            run = False 
 
    if not next: 
        start_screen() 
    if next: 
        real_name_screen() 
        if real_name_done: 
            char_name_screen() 
            if char_name_done: 
                #This is just so I could test it 
                print(real_name, char_name) 
                run = False 
 
 
 
    pygame.display.update() 
 
pygame.quit() 
quit() 

请您参考如下方法:

您需要一种方法来跟踪其中一个文本输入小部件是否处于事件状态,以及一种在所有小部件之间切换的方法。

我把这个例子拼凑在一起,根据需要进行调整(有很多可以改进的地方):

import os.path 
 
import pygame 
import pygame.locals as pl 
 
pygame.font.init() 
 
class WidgetManager: 
    def __init__(self): 
        self.widgets = [] 
 
    def update(self, events, dt): 
        for e in events: 
            if e.type == pygame.MOUSEBUTTONDOWN: 
                for w in self.widgets: 
                    w.active = False 
                    if w.rect.collidepoint(e.pos): 
                        w.active = True 
 
        for w in self.widgets: 
            w.update(events, dt) 
 
    def draw(self, surface): 
        for w in self.widgets: 
            surface.blit(w.surface, w.rect) 
 
class TextInput: 
    """ 
    This class lets the user input a piece of text, e.g. a name or a message. 
    This class let's the user input a short, one-lines piece of text at a blinking cursor 
    that can be moved using the arrow-keys. Delete, home and end work as well. 
    """ 
    def __init__( 
            self, 
            initial_string="", 
            font_family="", 
            font_size=35, 
            antialias=True, 
            active=False, 
            text_color=(0, 0, 0), 
            rect=pygame.Rect(0, 0, 10, 10), 
            cursor_color=(0, 0, 1), 
            repeat_keys_initial_ms=400, 
            repeat_keys_interval_ms=35): 
        """ 
        :param initial_string: Initial text to be displayed 
        :param font_family: name or list of names for font (see pygame.font.match_font for precise format) 
        :param font_size:  Size of font in pixels 
        :param antialias: Determines if antialias is applied to font (uses more processing power) 
        :param text_color: Color of text (duh) 
        :param cursor_color: Color of cursor 
        :param repeat_keys_initial_ms: Time in ms before keys are repeated when held 
        :param repeat_keys_interval_ms: Interval between key press repetition when helpd 
        """ 
 
        # Text related vars: 
        self.antialias = antialias 
        self.text_color = text_color 
        self.font_size = font_size 
        self.input_string = initial_string  # Inputted text 
        self.active = active 
        self.rect = rect 
 
        if not os.path.isfile(font_family): 
            font_family = pygame.font.match_font(font_family) 
 
        self.font_object = pygame.font.Font(font_family, font_size) 
 
        # Text-surface will be created during the first update call: 
        self.surface = pygame.Surface((1, 1)) 
        self.surface.set_alpha(0) 
 
        # Vars to make keydowns repeat after user pressed a key for some time: 
        self.keyrepeat_counters = {}  # {event.key: (counter_int, event.unicode)} (look for "***") 
        self.keyrepeat_intial_interval_ms = repeat_keys_initial_ms 
        self.keyrepeat_interval_ms = repeat_keys_interval_ms 
 
        # Things cursor: 
        self.cursor_surface = pygame.Surface((int(self.font_size/20+1), self.font_size)) 
        self.cursor_surface.fill(cursor_color) 
        self.cursor_position = len(initial_string)  # Inside text 
        self.cursor_visible = True  # Switches every self.cursor_switch_ms ms 
        self.cursor_switch_ms = 500  # /|\ 
        self.cursor_ms_counter = 0 
 
    def update(self, events, dt): 
        for event in events: 
            if event.type == pygame.KEYDOWN and self.active: 
                self.cursor_visible = True  # So the user sees where he writes 
 
                # If none exist, create counter for that key: 
                if event.key not in self.keyrepeat_counters: 
                    self.keyrepeat_counters[event.key] = [0, event.unicode] 
 
                if event.key == pl.K_BACKSPACE: 
                    self.input_string = ( 
                        self.input_string[:max(self.cursor_position - 1, 0)] 
                        + self.input_string[self.cursor_position:] 
                    ) 
 
                    # Subtract one from cursor_pos, but do not go below zero: 
                    self.cursor_position = max(self.cursor_position - 1, 0) 
                elif event.key == pl.K_DELETE: 
                    self.input_string = ( 
                        self.input_string[:self.cursor_position] 
                        + self.input_string[self.cursor_position + 1:] 
                    ) 
 
                elif event.key == pl.K_RETURN: 
                    return True 
 
                elif event.key == pl.K_RIGHT: 
                    # Add one to cursor_pos, but do not exceed len(input_string) 
                    self.cursor_position = min(self.cursor_position + 1, len(self.input_string)) 
 
                elif event.key == pl.K_LEFT: 
                    # Subtract one from cursor_pos, but do not go below zero: 
                    self.cursor_position = max(self.cursor_position - 1, 0) 
 
                elif event.key == pl.K_END: 
                    self.cursor_position = len(self.input_string) 
 
                elif event.key == pl.K_HOME: 
                    self.cursor_position = 0 
 
                else: 
                    # If no special key is pressed, add unicode of key to input_string 
                    self.input_string = ( 
                        self.input_string[:self.cursor_position] 
                        + event.unicode 
                        + self.input_string[self.cursor_position:] 
                    ) 
                    self.cursor_position += len(event.unicode)  # Some are empty, e.g. K_UP 
 
            elif event.type == pl.KEYUP: 
                # *** Because KEYUP doesn't include event.unicode, this dict is stored in such a weird way 
                if event.key in self.keyrepeat_counters: 
                    del self.keyrepeat_counters[event.key] 
 
        # Update key counters: 
        for key in self.keyrepeat_counters: 
            self.keyrepeat_counters[key][0] += dt  # Update clock 
 
            # Generate new key events if enough time has passed: 
            if self.keyrepeat_counters[key][0] >= self.keyrepeat_intial_interval_ms: 
                self.keyrepeat_counters[key][0] = ( 
                    self.keyrepeat_intial_interval_ms 
                    - self.keyrepeat_interval_ms 
                ) 
 
                event_key, event_unicode = key, self.keyrepeat_counters[key][1] 
                pygame.event.post(pygame.event.Event(pl.KEYDOWN, key=event_key, unicode=event_unicode)) 
 
        # Re-render text surface: 
        self.surface = pygame.Surface(self.rect.size) 
        self.surface.blit(self.font_object.render(self.input_string, self.antialias, self.text_color), (0, 0)) 
        pygame.draw.rect(self.surface, self.text_color, (0, 0, *self.rect.size), 1) 
 
        # Update self.cursor_visible 
        self.cursor_ms_counter += dt 
        if self.cursor_ms_counter >= self.cursor_switch_ms: 
            self.cursor_ms_counter %= self.cursor_switch_ms 
            self.cursor_visible = not self.cursor_visible 
 
        if self.cursor_visible and self.active: 
            cursor_y_pos = self.font_object.size(self.input_string[:self.cursor_position])[0] 
            # Without this, the cursor is invisible when self.cursor_position > 0: 
            if self.cursor_position > 0: 
                cursor_y_pos -= self.cursor_surface.get_width() 
            self.surface.blit(self.cursor_surface, (cursor_y_pos, 0)) 
 
        return False 
 
    def get_surface(self): 
        return self.surface 
 
    def get_text(self): 
        return self.input_string 
 
    def get_cursor_position(self): 
        return self.cursor_position 
 
    def set_text_color(self, color): 
        self.text_color = color 
 
    def set_cursor_color(self, color): 
        self.cursor_surface.fill(color) 
 
    def clear_text(self): 
        self.input_string = "" 
        self.cursor_position = 0 
 
def main(): 
    screen = pygame.display.set_mode((800, 600)) 
    clock = pygame.time.Clock() 
    manager = WidgetManager() 
    manager.widgets.append(TextInput(text_color=pygame.Color('grey'), cursor_color=pygame.Color('grey'), rect=pygame.Rect(5, 5, 790, 35))) 
    manager.widgets.append(TextInput(text_color=pygame.Color('orange'), cursor_color=pygame.Color('orange'), rect=pygame.Rect(5, 55, 790, 35), active=True)) 
    dt = 0 
    while True: 
        events = pygame.event.get() 
        for e in events: 
            if e.type == pygame.QUIT: 
                return 
        screen.fill((30, 30, 30)) 
        manager.draw(screen) 
        manager.update(events, dt) 
        dt = clock.tick() 
        pygame.display.update() 
 
if __name__ == '__main__': 
    main() 

您会看到 TextInput 现在有一个 active 标志。如果未设置,则忽略键输入。此外,我们将 TextInput 的位置和大小存储在新属性 rect 中,因此新类 WidgetManager 可以通过单击一个小部件在小部件之间切换用鼠标。

我还从 TextInput 类中删除了 Clock,因为调用 self.clock.tick() 是主循环应该做的事情.