Skip to content
TheChatArchiveThe Chat Archive
gpt-4.1-mini-2025-04-14· OpenAIAi2 WildChat-4.8M (AI2)

oque em python da para fazer para o blender3d?

  1. User

    oque em python da para fazer para o blender3d?

  2. Assistant

    Em Python, para o Blender 3D, você pode fazer uma enorme variedade de coisas, pois o Blender possui uma API muito poderosa e extensível que permite automatizar praticamente qualquer aspecto do software. Aqui estão alguns exemplos do que é possível fazer com Python no Blender:

    1. Automatizar tarefas e modelagem procedural

    • Criar e modificar malhas programaticamente (vertices, arestas, faces).
    • Aplicar transformações (translação, rotação, escala).
    • Gerar geometrias complexas de forma procedural.
    • Criar scripts para acelerar seu fluxo de trabalho (por exemplo, renomear objetos em lote, organizar cenas etc).

    2. Criar Add-ons e ferramentas personalizadas

    • Desenvolver painéis, menus, operadores e interfaces no Blender.
    • Criar ferramentas específicas para seu projeto ou pipeline.
    • Incorporar controles customizados na interface do Blender.

    3. Automatizar animações

    • Criar keyframes programaticamente para animar objetos, câmeras e luzes.
    • Gerenciar curvas de animação (F-curves).
    • Gerar simulações e controlar físicas via script.

    4. Manipular materiais e shaders

    • Criar, modificar e conectar nodes de materiais no compositor e no shader node editor.
    • Automatizar a criação de materiais complexos.

    5. Renderização e controle de cenas

    • Configurar configurações de render.
    • Renderizar imagens, vídeos e sequências automaticamente.
    • Exportar e importar dados de cena para integração com outros softwares.

    6. Manipulação de dados da cena

    • Ler e modificar propriedades de objetos, câmeras, luzes, meshes, armaduras (armatures), partículas, etc.
    • Criar rigs automatizados ou ferramentas para animação.

    7. Integração com outras ferramentas e pipelines

    • Importar/exportar formatos personalizados.
    • Comunicação com softwares externos, bancos de dados ou servidores via sockets, HTTP, etc.

    Exemplo simples: Criar um cubo via script Python no Blender

    import bpy
    
    # Remove todos os objetos
    bpy.ops.object.select_all(action='SELECT')
    bpy.ops.object.delete(use_global=False)
    
    # Cria um cubo na cena
    bpy.ops.mesh.primitive_cube_add(size=2, location=(0, 0, 0))
    
    # Seleciona o cubo criado
    cube = bpy.context.active_object
    cube.name = "MeuCubo"
    
    # Move o cubo em z para cima
    cube.location.z = 1
    

    Esse simples script cria um cubo, dá um nome a ele e move um pouco para cima.


    Ressources úteis

    Se você tiver algum objetivo específico com Blender + Python, posso ajudar a criar um script ou dar ideias de como partir dele!

  3. User

    addon para animação

  4. Assistant

    Criar um addon para animação no Blender usando Python pode ser uma forma muito útil de customizar e acelerar seu fluxo de trabalho. Abaixo vou explicar como criar um addon básico que automatiza uma tarefa simples de animação — por exemplo, criar uma animação que move um objeto na cena automaticamente.


    Exemplo de Addon básico para animação

    Esse addon vai:

    • Criar um painel na aba da View3D (3D Viewport).
    • Permitir que o usuário selecione um objeto e clique em um botão para criar uma animação simples (movimentar o objeto em X).

    Passo 1 - Estrutura mínima do addon

    bl_info = {
        "name": "Simple Animation Addon",
        "author": "Seu Nome",
        "version": (1, 0),
        "blender": (2, 80, 0),
        "location": "View3D > Sidebar > Simple Animation",
        "description": "Cria uma animação simples movendo o objeto selecionado",
        "category": "Animation"
    }
    
    import bpy
    
    class OBJECT_OT_simple_animation(bpy.types.Operator):
        bl_idname = "object.simple_animation"
        bl_label = "Criar animação"
        bl_description = "Anima o objeto selecionado movendo no eixo X"
        bl_options = {'REGISTER', 'UNDO'}
    
        def execute(self, context):
            obj = context.active_object
            if obj is None:
                self.report({'WARNING'}, "Nenhum objeto selecionado")
                return {'CANCELLED'}
            
            # Define os frames
            start_frame = 1
            end_frame = 50
            
            # Move o objeto para posição inicial e insere keyframe de localização
            obj.location.x = 0
            obj.keyframe_insert(data_path="location", frame=start_frame)
            
            # Move o objeto para posição final e insere keyframe de localização
            obj.location.x = 5
            obj.keyframe_insert(data_path="location", frame=end_frame)
            
            self.report({'INFO'}, f"Animação criada para {obj.name}")
            return {'FINISHED'}
    
    class SIMPLEANIM_PT_panel(bpy.types.Panel):
        bl_label = "Simple Animation"
        bl_idname = "SIMPLEANIM_PT_panel"
        bl_space_type = 'VIEW_3D'
        bl_region_type = 'UI'  # Sidebar
        bl_category = 'Simple Animation'
    
        def draw(self, context):
            layout = self.layout
            layout.label(text="Animação simples para objeto selecionado:")
            layout.operator("object.simple_animation")
    
    def register():
        bpy.utils.register_class(OBJECT_OT_simple_animation)
        bpy.utils.register_class(SIMPLEANIM_PT_panel)
    
    def unregister():
        bpy.utils.unregister_class(OBJECT_OT_simple_animation)
        bpy.utils.unregister_class(SIMPLEANIM_PT_panel)
    
    if __name__ == "__main__":
        register()
    

    Como usar

    1. Salve esse script em um arquivo .py, por exemplo simple_animation_addon.py.
    2. No Blender, vá em Edit > Preferences > Add-ons > Install... e selecione o arquivo salvo.
    3. Ative o addon.
    4. No 3D Viewport, abra a Sidebar (tecla N) e verá uma aba chamada Simple Animation.
    5. Selecione um objeto na cena e clique no botão Criar animação.
    6. O objeto será animado da posição X=0 para X=5 do frame 1 ao frame 50.

    Expandindo o addon

    Você pode melhorar o addon incluindo:

    • Inputs para personalizar valores: posição inicial/final, eixos, duração da animação.
    • Animação em outros tipos de propriedades (rotação, escala).
    • Criação de keyframes para múltiplos objetos ao mesmo tempo.
    • Suporte a curvas de animação (F-curves) mais complexas.
    • Integração com outros operadores.

    Se quiser posso ajudar a criar addons mais sofisticados ou focados em funcionalidades específicas para animação! Quer que eu faça um exemplo mais elaborado?

  5. User

    addon avançado

  6. Assistant

    Claro! Vamos criar um addon mais avançado para animação no Blender com Python, que inclui:

    • Interface com propriedades personalizadas (inputs do usuário).
    • Animação configurável (posição inicial e final, duração da animação, eixo de movimento).
    • Suporte para múltiplos objetos selecionados.
    • Botão para limpar as animações criadas.
    • Visual feedback e mensagens adequadas.

    Addon Python avançado para animação no Blender

    Salve como, por exemplo, advanced_animation_addon.py

    bl_info = {
        "name": "Advanced Animation Toolkit",
        "author": "Seu Nome",
        "version": (1, 0, 0),
        "blender": (2, 80, 0),
        "location": "View3D > Sidebar > Adv Animation",
        "description": "Ani­ma­ção customizada para múltiplos objetos com controle via UI",
        "category": "Animation"
    }
    
    import bpy
    from bpy.props import (
        FloatProperty,
        IntProperty,
        EnumProperty,
        BoolProperty,
        CollectionProperty,
    )
    
    # -----------------------------------
    # Operator para aplicar animação
    # -----------------------------------
    class ADVANIM_OT_apply_animation(bpy.types.Operator):
        bl_idname = "advanim.apply_animation"
        bl_label = "Aplicar animação"
        bl_description = "Anima os objetos selecionados com os parâmetros definidos"
        bl_options = {'REGISTER', 'UNDO'}
    
        def execute(self, context):
            scene = context.scene
            props = scene.adv_anim_props
            objs = context.selected_objects
            
            if not objs:
                self.report({'WARNING'}, "Nenhum objeto selecionado")
                return {'CANCELLED'}
            
            axis_index = {'X':0, 'Y':1, 'Z':2}[props.axis]
            start_frame = props.start_frame
            end_frame = props.end_frame
            
            for obj in objs:
                # Apaga keyframes existentes na propriedade location para os frames do intervalo
                obj.animation_data_clear()
    
                # Move objeto para posição inicial e cria keyframe
                loc = list(obj.location)
                loc[axis_index] = props.start_pos
                obj.location = loc
                obj.keyframe_insert(data_path="location", frame=start_frame)
    
                # Move objeto para posição final e cria keyframe
                loc[axis_index] = props.end_pos
                obj.location = loc
                obj.keyframe_insert(data_path="location", frame=end_frame)
            
            self.report({'INFO'}, f"Animação aplicada em {len(objs)} objeto(s)")
            return {'FINISHED'}
    
    # -----------------------------------
    # Operator para limpar animação
    # -----------------------------------
    class ADVANIM_OT_clear_animation(bpy.types.Operator):
        bl_idname = "advanim.clear_animation"
        bl_label = "Limpar animação"
        bl_description = "Remove keyframes de localização dos objetos selecionados"
        bl_options = {'REGISTER', 'UNDO'}
        
        def execute(self, context):
            objs = context.selected_objects
            if not objs:
                self.report({'WARNING'}, "Nenhum objeto selecionado")
                return {'CANCELLED'}
            count = 0
            for obj in objs:
                if obj.animation_data:
                    obj.animation_data_clear()
                    count += 1
            self.report({'INFO'}, f"Animação removida de {count} objeto(s)")
            return {'FINISHED'}
    
    # -----------------------------------
    # Propriedades da UI
    # -----------------------------------
    class ADVANIM_Properties(bpy.types.PropertyGroup):
        start_pos: FloatProperty(
            name="Posição Inicial",
            description="Posição inicial no eixo selecionado",
            default=0.0,
            step=0.1,
            precision=3,
        )
        
        end_pos: FloatProperty(
            name="Posição Final",
            description="Posição final no eixo selecionado",
            default=5.0,
            step=0.1,
            precision=3,
        )
        
        start_frame: IntProperty(
            name="Frame Inicial",
            description="Frame inicial da animação",
            default=1,
            min=1,
            max=10000,
        )
        
        end_frame: IntProperty(
            name="Frame Final",
            description="Frame final da animação",
            default=50,
            min=1,
            max=10000,
        )
        
        axis: EnumProperty(
            items=[
                ('X', 'X', 'Eixo X'),
                ('Y', 'Y', 'Eixo Y'),
                ('Z', 'Z', 'Eixo Z')
            ],
            name="Eixo",
            description="Eixo onde a animação ocorrerá",
            default='X',
        )
        
        auto_play: BoolProperty(
            name="Reproduzir após criar",
            description="Alterna para frame inicial após aplicar animação",
            default=True,
        )
    
    
    # -----------------------------------
    # Painel principal
    # -----------------------------------
    class ADVANIM_PT_panel(bpy.types.Panel):
        bl_label = "Advanced Animation Toolkit"
        bl_idname = "ADVANIM_PT_panel"
        bl_space_type = 'VIEW_3D'
        bl_region_type = 'UI' 
        bl_category = "Adv Animation"
        
        def draw(self, context):
            layout = self.layout
            scene = context.scene
            props = scene.adv_anim_props
            
            layout.label(text="Parâmetros da Animação")
            layout.prop(props, "axis")
            layout.prop(props, "start_pos")
            layout.prop(props, "end_pos")
            layout.prop(props, "start_frame")
            layout.prop(props, "end_frame")
            layout.prop(props, "auto_play")
            
            layout.separator()
            layout.label(text="Objetos selecionados: " + str(len(context.selected_objects)))
            
            row = layout.row()
            row.operator("advanim.apply_animation", icon='PLAY')
            row.operator("advanim.clear_animation", icon='X')
    
    # -----------------------------------
    # Registro
    # -----------------------------------
    classes = (
        ADVANIM_OT_apply_animation,
        ADVANIM_OT_clear_animation,
        ADVANIM_Properties,
        ADVANIM_PT_panel,
    )
    
    def register():
        for cls in classes:
            bpy.utils.register_class(cls)
        bpy.types.Scene.adv_anim_props = bpy.props.PointerProperty(type=ADVANIM_Properties)
    
    def unregister():
        for cls in reversed(classes):
            bpy.utils.unregister_class(cls)
        del bpy.types.Scene.adv_anim_props
    
    if __name__ == "__main__":
        register()
    

    Como usar

    1. Salve o código acima num arquivo .py (ex: advanced_animation_addon.py).
    2. No Blender, vá em Edit > Preferences > Add-ons > Install... e selecione o arquivo.
    3. Ative o addon.
    4. Na aba lateral (Sidebar, tecla N) do 3D Viewport, aparecerá a aba Adv Animation.
    5. Selecione um ou mais objetos.
    6. Configure:
      • Eixo (X, Y ou Z).
      • Posição inicial e final.
      • Frame inicial e final.
      • Se deseja voltar para o início da animação automaticamente.
    7. Clique em Aplicar animação para criar a animação.
    8. Clique em Limpar animação para remover as keyframes de locação dos objetos.

    O que esse addon faz

    • Cria uma animação linear simples que move um ou vários objetos selecionados, no eixo escolhido, do ponto inicial ao final no intervalo de frames especificados.
    • Limpa as animações de localização que os objetos tenham.
    • Interface simples e clara com propriedades para o usuário customizar a animação.
    • Feedback por mensagens (por exemplo, notificações de sucesso/erro).

    Se desejar, posso ajudar a adicionar recursos mais avançados, como interpolação customizada, manipulação de rotação/escala, criação de rigs automatizados, integração com shape keys, etc. Quer seguir para algo mais complexo?

  7. User

    addon para upbge

  8. Assistant

    O UPBGE (que é um fork do Blender focado em engine de jogos) também suporta scripting Python para controlar a lógica dos jogos e animações. Porém, sua API é diferente da API padrão do Blender para modelagem e animação, pois o foco é em lógica em tempo real no motor de jogos.


    Sobre Add-ons no UPBGE

    • UPBGE usa Python para logic bricks (lógica do jogo), normalmente via scripts que respondem a eventos.
    • Não usa add-ons no sentido tradicional do Blender para estender a interface, mas você pode criar scripts Python que controlam a lógica do jogo no tempo de execução, e pode criar ferramentas externas para o Blender que geram assets para o UPBGE também.
    • Para manipular a lógica em tempo real, scripts são associados a objetos via “Logic Bricks” -> “Python Controller”.

    Exemplo simples de script Python no UPBGE

    Um script para fazer um objeto se mover em jogo, você criaria um arquivo .py com lógica como:

    import bge
    
    def move_object(cont):
        obj = cont.owner  # objeto controlador (aquele que usa o script)
    
        speed = 0.1
        # Move para frente no eixo local Y
        obj.applyMovement([0, speed, 0], True)
    

    No editor do UPBGE:

    • Adicione um sensor (ex: Always).
    • Conecte a um controller Python (que usa o script acima).
    • Esse controller controlará o objeto no jogo.

    Criando um Add-on para UPBGE? (ferramenta para exportação/configuração)

    Na prática, o termo "addon para UPBGE" geralmente se refere a:

    1. Scripts/tools para Blender que facilitam a criação de assets para o UPBGE, ou
    2. Scripts Python para a lógica do jogo dentro do UPBGE.

    Se você queria um exemplo de script Python para usar dentro do UPBGE como parte da lógica do jogo, aqui vai um exemplo mais completo para animação (movimento simples):

    import bge
    
    def animate_move(cont):
        obj = cont.owner
    
        # Propriedades personalizadas no objeto para controlar movimento
        speed = obj.get("speed", 0.1)
        max_distance = obj.get("max_distance", 5.0)
    
        # Valor interno para acompanhar a distância percorrida
        distance = obj.get("distance", 0.0)
    
        # Se não ultrapassou max_distance, move
        if distance < max_distance:
            obj.applyMovement([speed, 0, 0], True)  # movimenta local no eixo X
            distance += speed
            obj["distance"] = distance
        else:
            obj["distance"] = 0.0  # reseta (ou poderia parar animação)
    

    Para usar:

    • Adicione esse script a um controller Python.
    • Defina as propriedades (no painel de propriedades do objeto) speed e max_distance para controlar o movimento.

    Resumo para você usar Python no UPBGE

    • Não são add-ons no Blender, mas scripts Python rodando dentro da engine para lógica do jogo.
    • Você pode criar scripts para controlar animação, movimento, física e interatividade em tempo real.
    • Se quiser criar uma UI customizada para ferramentas no Blender para UPBGE, aí sim um add-on para Blender pode ser criado usando a API normal do Blender.

    Se quiser, posso ajudar fazendo:

    • Um exemplo de script Python para animação no UPBGE.
    • Um addon para Blender que exporta ou prepara cenas para UPBGE.
    • Ou explicações detalhadas de lógica usando lógica bricks + scripts Python no UPBGE.

    Quer seguir com algum desses?

  9. User

    addon para gerar objetos já com logica configurada

  10. Assistant

    Legal! Criar um addon para Blender (que funcione bem com UPBGE) para gerar objetos já configurados com lógica de jogo (logic bricks + scripts Python) é uma excelente forma de acelerar a criação de cenas e protótipos.


    O que vamos fazer?

    Vamos criar um addon que:

    • Cria um objeto (ex: cubo).
    • Automatiza a configuração dos logic bricks básicos:
      • Um sensor Always para o objeto executar um script sempre no jogo.
      • Um controller Python atrelado a um script embedado.
    • Cria o script Python dentro do próprio Blender (Text Editor), para que o logic brick aponte para ele.
    • Configura tudo via script Python para UPBGE.

    Código completo do addon exemplo

    Salve como, por exemplo, upbge_object_creator.py

    bl_info = {
        "name": "UPBGE Object Creator",
        "author": "Seu Nome",
        "version": (1, 0, 0),
        "blender": (2, 80, 0),
        "location": "View3D > Sidebar > UPBGE Tools",
        "description": "Cria objetos com lógica básica automaticamente para UPBGE",
        "category": "Game Engine"
    }
    
    import bpy
    
    def create_upbge_logic(obj, script_name, script_code):
        '''
        Configura logic bricks para o objeto:
        - Sensor Always
        - Python controller que chama script_name
        - Cria script no Text Editor se não existir
        '''
        # Cria sensor Always (se não existir)
        contr = None
        sensors = obj.game.sensors
        controllers = obj.game.controllers
    
        # Remove sensors/controllers anteriores para evitar duplicação
        while sensors:
            sensors.remove(sensors[0])
        while controllers:
            controllers.remove(controllers[0])
    
        sensor = sensors.new(type='ALWAYS')
        sensor.use_pulse_true_level = True
    
        controller = controllers.new(type='PYTHON')
        controller.mode = 'SCRIPT'
        controller.script = script_name
        controller.link(sensor)
    
        # Cria ou atualiza o script no Text Editor do Blender
        txt = bpy.data.texts.get(script_name)
        if not txt:
            txt = bpy.data.texts.new(script_name)
        txt.from_string(script_code)
    
    class UPBGETOOLS_OT_create_object_game_logic(bpy.types.Operator):
        bl_idname = "upbgetools.create_object_game_logic"
        bl_label = "Criar objeto com lógica UPBGE"
        bl_description = "Cria um cubo com lógica básica pronta para UPBGE"
        bl_options = {'REGISTER', 'UNDO'}
    
        def execute(self, context):
            # Cria objeto cubo
            bpy.ops.mesh.primitive_cube_add(size=2)
            obj = context.active_object
            obj.name = "UPBGE_Objeto"
    
            # Ativa o modo 'Game' para o objeto
            obj.game.use_collision_bounds = True
            obj.game.collision_bounds_type = 'BOX'
    
            # Código exemplo para o script Python do logic brick
            script_name = "upbge_move_object.py"
            script_code = '''\
    import bge
    
    def main(cont):
        obj = cont.owner
        speed = 0.1
    
        # Move o objeto para frente no eixo local Y
        obj.applyMovement([0, speed, 0], True)
    '''
    
            # Configura lógica UPBGE no objeto
            create_upbge_logic(obj, script_name, script_code)
    
            self.report({'INFO'}, "Objeto criado com lógica para UPBGE")
    
            return {'FINISHED'}
    
    class UPBGETOOLS_PT_panel(bpy.types.Panel):
        bl_label = "UPBGE Tools"
        bl_idname = "UPBGETOOLS_PT_panel"
        bl_space_type = 'VIEW_3D'
        bl_region_type = 'UI'
        bl_category = "UPBGE Tools"
    
        def draw(self, context):
            layout = self.layout
            layout.label(text="Criar objeto para UPBGE")
            layout.operator("upbgetools.create_object_game_logic")
    
    classes = (
        UPBGETOOLS_OT_create_object_game_logic,
        UPBGETOOLS_PT_panel,
    )
    
    def register():
        for cls in classes:
            bpy.utils.register_class(cls)
    
    def unregister():
        for cls in reversed(classes):
            bpy.utils.unregister_class(cls)
    
    if __name__ == "__main__":
        register()
    

    Como usar

    1. Salve o script acima como upbge_object_creator.py.
    2. No Blender (com UPBGE ou Blender padrão usado para preparar assets), vá em Edit > Preferences > Add-ons > Install..., selecione o arquivo.
    3. Ative o addon.
    4. No 3D View (viewport), abra a Sidebar (Tecla N) e vá até a aba UPBGE Tools.
    5. Clique no botão Criar objeto com lógica UPBGE.
    6. Será criado um cubo na cena chamado UPBGE_Objeto já com os logic bricks configurados:
      • Sensor Always
      • Python Controller que chama o script upbge_move_object.py
    7. O script também é criado no Text Editor do Blender e no jogo fará com que o cubo se mova lentamente no eixo local Y.

    Próximos passos e customizações

    • Você pode expandir o addon para criar outros objetos com lógicas diferenciadas.
    • Criar UI para escolher o tipo da lógica (movimentação, rotação, troca de cena, etc).
    • Acrescentar lógica mais complexa (sensores de colisão, mouse, teclado).
    • Criar templates de scripts externos e importar automaticamente para o Blender.

    Se quiser posso ajudar a deixar o addon mais customizável, com opções para diferentes lógicas ou comportamentos. Quer?

  11. User

    addon para game completo, já com lógica configurada

  12. Assistant

    Criar um addon para Blender/UPBGE que gera um jogo completo com lógica configurada automaticamente é algo mais complexo, mas totalmente possível criando uma base sólida e modular — gerando por exemplo um pequeno cenário, personagens, câmeras, lógica de movimento, sistema básico de jogo (colete itens, condição de vitória, etc).

    Vou criar um exemplo básico que cria na cena:

    • Um personagem (cubo) com controle de movimento WASD.
    • Um item colecionável (esfera) que desaparece ao colidir com personagem.
    • Uma câmera que segue o personagem.
    • Um sistema básico de pontuação exibido no console (exemplo básico, pode ser extendido).

    Addon UPBGE: Mini jogo básico completo

    Salve como upbge_game_creator.py e instale no Blender/UPBGE.

    bl_info = {
        "name": "UPBGE Mini Game Creator",
        "author": "Seu Nome",
        "version": (1, 0, 0),
        "blender": (2, 80, 0),
        "location": "View3D > Sidebar > UPBGE Game",
        "description": "Cria uma cena com lógica básica de jogo (movimento, coleta, câmera)",
        "category": "Game Engine"
    }
    
    import bpy
    
    def create_text_script(script_name, script_code):
        txt = bpy.data.texts.get(script_name)
        if txt is None:
            txt = bpy.data.texts.new(script_name)
        txt.clear()
        txt.write(script_code)
        return txt
    
    def setup_logic_bricks(obj, sensors_info, controllers_info, links_info):
        # Remove sensores e controllers antigos
        sensors = obj.game.sensors
        controllers = obj.game.controllers
        while sensors:
            sensors.remove(sensors[0])
        while controllers:
            controllers.remove(controllers[0])
        
        sens = {}
        conts = {}
    
        for s in sensors_info:
            sens_obj = sensors.new(type=s['type'])
            for prop, val in s.items():
                if prop != 'type':
                    setattr(sens_obj, prop, val)
            sens[s['name']] = sens_obj
    
        for c in controllers_info:
            cont_obj = controllers.new(type=c['type'])
            for prop, val in c.items():
                if prop not in ['type', 'script']:
                    setattr(cont_obj, prop, val)
                if 'script' in c:
                    cont_obj.script = c['script']
            conts[c['name']] = cont_obj
    
        # Link sensors to controllers
        for link in links_info:
            s_name = link['sensor']
            c_name = link['controller']
            if s_name in sens and c_name in conts:
                conts[c_name].link(sens[s_name])
    
    def create_player():
        bpy.ops.mesh.primitive_cube_add(size=1)
        player = bpy.context.active_object
        player.name = "Player"
        player.location = (0, 0, 1)
        player.game.use_collision_bounds = True
        player.game.collision_bounds_type = 'BOX'
    
        move_script = """
    import bge
    
    def main(cont):
        obj = cont.owner
        keyboard = bge.logic.keyboard
        speed = 0.1
        from bge import events
    
        # Movimento WASD
        if keyboard.events[bge.events.WKEY] == bge.logic.KX_INPUT_ACTIVE:
            obj.applyMovement([0, speed, 0], True)
        if keyboard.events[bge.events.SKEY] == bge.logic.KX_INPUT_ACTIVE:
            obj.applyMovement([0, -speed, 0], True)
        if keyboard.events[bge.events.AKEY] == bge.logic.KX_INPUT_ACTIVE:
            obj.applyMovement([-speed, 0, 0], True)
        if keyboard.events[bge.events.DKEY] == bge.logic.KX_INPUT_ACTIVE:
            obj.applyMovement([speed, 0, 0], True)
    """
        create_text_script("player_move.py", move_script)
    
        sensors_info = [
            {'name': 'Always', 'type': 'ALWAYS', 'use_pulse_true_level': True}
        ]
        controllers_info = [
            {'name': 'PythonMove', 'type': 'PYTHON', 'mode': 'SCRIPT', 'script': 'player_move.py'}
        ]
        links_info = [{'sensor': 'Always', 'controller': 'PythonMove'}]
    
        setup_logic_bricks(player, sensors_info, controllers_info, links_info)
        return player
    
    def create_collectible(location=(3,0,1)):
        bpy.ops.mesh.primitive_ico_sphere_add(radius=0.5, location=location)
        coin = bpy.context.active_object
        coin.name = "Collectible"
        coin.game.use_collision_bounds = True
        coin.game.collision_bounds_type = 'SPHERE'
    
        collectible_script = """
    import bge
    
    def main(cont):
        own = cont.owner
        collision_sensor = cont.sensors['Collision']
        if collision_sensor.positive:
            # Destrói o objeto colecionável na colisão
            own.endObject()
            print('Item coletado!')
    """
        create_text_script("collectible_logic.py", collectible_script)
    
        sensors_info = [
            {'name': 'Collision', 'type': 'COLLISION', 'collision_mask': 1, 'use_pulse_true_level': True}
        ]
        controllers_info = [
            {'name': 'PythonCollect', 'type': 'PYTHON', 'mode': 'SCRIPT', 'script': 'collectible_logic.py'}
        ]
        links_info = [{'sensor': 'Collision', 'controller': 'PythonCollect'}]
    
        setup_logic_bricks(coin, sensors_info, controllers_info, links_info)
    
        # Ajusta o collision group/mask para colidir com o player (que fica no group 1)
        coin.game.collision_group = 2
        coin.game.collision_mask = 1
    
        return coin
    
    def create_camera_follow(target):
        bpy.ops.object.camera_add(location=(0, -10, 5))
        cam = bpy.context.active_object
        cam.name = "GameCamera"
        cam.rotation_euler = (1.2, 0, 0)
    
        camera_script = """
    import bge
    
    def main(cont):
        cam = cont.owner
        scene = bge.logic.getCurrentScene()
        player = scene.objects.get('Player')
        if player:
            cam.position = player.position + [0, -10, 5]
            cam.lookAt(player)
    """
        create_text_script("camera_follow.py", camera_script)
    
        sensors_info = [
            {'name': 'Always', 'type': 'ALWAYS', 'use_pulse_true_level': True}
        ]
        controllers_info = [
            {'name': 'PythonCam', 'type': 'PYTHON', 'mode': 'SCRIPT', 'script': 'camera_follow.py'}
        ]
        links_info = [{'sensor': 'Always', 'controller': 'PythonCam'}]
    
        setup_logic_bricks(cam, sensors_info, controllers_info, links_info)
    
        return cam
    
    class UPBGEGAME_OT_create_game(bpy.types.Operator):
        bl_idname = "upbgegame.create_game"
        bl_label = "Criar mini jogo UPBGE"
        bl_description = "Cria uma cena básica com personagem, item colecionável e câmera com lógica"
        bl_options = {'REGISTER', 'UNDO'}
    
        def execute(self, context):
            # Deleta objetos da cena atual para limpar
            bpy.ops.object.select_all(action='SELECT')
            bpy.ops.object.delete(use_global=False)
    
            player = create_player()
            create_collectible(location=(3,0,1))
            create_collectible(location=(-3,2,1))
            create_camera_follow(player)
    
            self.report({'INFO'}, "Mini jogo criado! Pressione P para jogar.")
            return {'FINISHED'}
    
    class UPBGEGAME_PT_panel(bpy.types.Panel):
        bl_label = "UPBGE Mini Game"
        bl_idname = "UPBGEGAME_PT_panel"
        bl_space_type = 'VIEW_3D'
        bl_region_type = 'UI'
        bl_category = "UPBGE Game"
    
        def draw(self, context):
            layout = self.layout
            layout.operator("upbgegame.create_game", icon='GAME')
    
    classes = (
        UPBGEGAME_OT_create_game,
        UPBGEGAME_PT_panel,
    )
    
    def register():
        for cls in classes:
            bpy.utils.register_class(cls)
    
    def unregister():
        for cls in reversed(classes):
            bpy.utils.unregister_class(cls)
    
    if __name__ == "__main__":
        register()
    

    Como usar

    1. Salve esse script como upbge_game_creator.py.
    2. Instale e ative o addon no Blender/UPBGE.
    3. No 3D Viewport, abra a sidebar (N) e clique na aba UPBGE Game.
    4. Clique em Criar mini jogo UPBGE.
    5. A cena será limpa e criada com:
      • Cubo player controlado por tecla WASD.
      • Dois “coins” (esferas) para coletar.
      • Câmera seguindo o player.
    6. Pressione P para iniciar o jogo no UPBGE.

    O que pode melhorar

    • Interface para ajustar parâmetros (velocidade, quantidade de itens).
    • UI in-game para pontuação.
    • Sons e efeitos visuais.
    • Transições, menus, estados do jogo (win/lose).
    • Melhoria na câmera (suave, responsiva).
    • Salvamento de progresso e variáveis globais.

    Quer que eu te ajude a criar essas melhorias ou outro tipo de jogo mais complexo?

  13. User

    não apareceu a opção: Criar mini jogo UPBGE.

  14. Assistant

    Se a aba UPBGE Game e o botão Criar mini jogo UPBGE não apareceram na Sidebar após instalar e ativar o addon, alguns passos e verificações podem ajudar a solucionar:


    Passos de verificação e solução

    1. Confirmar se o addon está ativado

    • Vá em Edit > Preferences > Add-ons.
    • Busque pelo nome do addon (ex: "UPBGE Mini Game Creator").
    • Verifique se o checkbox está marcado para ativar.

    2. Abrir a Sidebar correta

    • No 3D Viewport, use a tecla N para abrir a Sidebar (painel lateral).
    • Verifique se existe uma aba/tab chamada UPBGE Game.

    Observação: O painel criado no código usa

    bl_space_type = 'VIEW_3D'
    bl_region_type = 'UI'
    bl_category = "UPBGE Game"
    

    Isso significa que a aba aparece no Sidebar do editor 3D Viewport, região UI.

    3. Testar se o painel aparece no Scripting Editor

    Opcionalmente, teste criando um painel no Text Editor para confirmar se o addon está funcionando, para descartar erro de ambiente.

    4. Certifique-se de que o arquivo foi salvo e instalado corretamente

    • Salve o script exatamente com extensão .py.
    • No Blender, use Edit > Preferences > Add-ons > Install....
    • Selecione o arquivo e ative a checkbox.

    5. Console do Blender: Verifique erros

    • Abra o Console do Blender (Window > Toggle System Console ou de acordo com seu SO).
    • Veja se aparecem erros ao carregar ou executar o addon.

    6. Versão do Blender compatível

    • O addon especifica "blender": (2, 80, 0), certifique-se de usar Blender 2.80+ ou UPBGE baseado nessa versão.
    • Incompatibilidades podem impedir o painel de surgir.

    Código rápido para testar se a aba aparece

    Cole esse código simples no Text Editor e clique em Run Script.

    import bpy
    
    class TEST_PT_panel(bpy.types.Panel):
        bl_label = "Teste de Painel"
        bl_idname = "TEST_PT_panel"
        bl_space_type = "VIEW_3D"
        bl_region_type = "UI"
        bl_category = "Teste"
    
        def draw(self, context):
            self.layout.label(text="Painel Teste Funcionando!")
    
    def register():
        bpy.utils.register_class(TEST_PT_panel)
    
    def unregister():
        bpy.utils.unregister_class(TEST_PT_panel)
    
    register()
    
    • Após rodar, pressione N no 3D View e veja se a aba Teste aparece.
    • Se aparecer, o problema está no código do addon.
    • Se não aparecer, problema pode estar no Blender ou ambiente.

    Tips para corrigir no addon real

    1. Forçar o registro imediato no final do arquivo

    No addon, ao final, rode:

    if __name__ == "__main__":
        register()
    
    1. Executar registro no ambiente Blender

    Às vezes, editar e reexecutar o código sem registrar corretamente pode impedir painel aparecer.

    1. Verifique identação e erros nos nomes

    Erros simples podem impedir o painel de adicionar.

    1. Verifique se o painel não está filtrado

    Se no Sidebar a aba não aparece, tente:

    • Clicar com botão direito no cabeçalho da Sidebar, confirmar se a aba está "ativada".

    Se quiser, me envie o arquivo .py que você está usando para eu revisar, ou posso gerar um arquivo .zip comentado para você.


    Estou à disposição para ajudar até o painel e a funcionalidade aparecerem certinho! Querprosseguir?

  15. User

    aplique a correção no addon completo

  16. Assistant

    Claro! Vou ajustar o addon completo para garantir que o painel apareça corretamente na Sidebar do 3D Viewport, incluindo um registro robusto e pequenos ajustes para evitar problemas comuns. Também vou adicionar um breve feedback visual para confirmar que o botão está lá.

    Segue o código revisado e corrigido (salve como upbge_game_creator.py):

    bl_info = {
        "name": "UPBGE Mini Game Creator",
        "author": "Seu Nome",
        "version": (1, 0, 0),
        "blender": (2, 80, 0),
        "location": "View3D > Sidebar > UPBGE Game",
        "description": "Cria uma cena com lógica básica de jogo (movimento, coleta, câmera)",
        "category": "Game Engine"
    }
    
    import bpy
    
    def create_text_script(script_name, script_code):
        txt = bpy.data.texts.get(script_name)
        if txt is None:
            txt = bpy.data.texts.new(script_name)
        else:
            txt.clear()
        txt.write(script_code)
        return txt
    
    def setup_logic_bricks(obj, sensors_info, controllers_info, links_info):
        # Remove sensores e controllers antigos
        sensors = obj.game.sensors
        controllers = obj.game.controllers
        while sensors:
            sensors.remove(sensors[0])
        while controllers:
            controllers.remove(controllers[0])
        
        sens = {}
        conts = {}
    
        for s in sensors_info:
            sens_obj = sensors.new(type=s['type'])
            sens_obj.name = s.get('name', sens_obj.name)
            for prop, val in s.items():
                if prop != 'type' and prop != 'name':
                    setattr(sens_obj, prop, val)
            sens[s['name']] = sens_obj
    
        for c in controllers_info:
            cont_obj = controllers.new(type=c['type'])
            cont_obj.name = c.get('name', cont_obj.name)
            for prop, val in c.items():
                if prop not in ['type', 'script', 'name']:
                    setattr(cont_obj, prop, val)
            if 'script' in c:
                cont_obj.mode = 'SCRIPT'
                cont_obj.script = c['script']
            conts[c['name']] = cont_obj
    
        # Link sensors to controllers
        for link in links_info:
            s_name = link['sensor']
            c_name = link['controller']
            if s_name in sens and c_name in conts:
                conts[c_name].link(sens[s_name])
    
    def create_player():
        bpy.ops.mesh.primitive_cube_add(size=1)
        player = bpy.context.active_object
        player.name = "Player"
        player.location = (0, 0, 1)
        player.game.use_collision_bounds = True
        player.game.collision_bounds_type = 'BOX'
        player.game.collision_group = 1  # Grupo de colisão 1
        player.game.collision_mask = 2   # Detecta colisões com grupo 2 (itens)
    
        move_script = """
    import bge
    
    def main(cont):
        obj = cont.owner
        keyboard = bge.logic.keyboard
        speed = 0.1
        from bge import events
    
        # Movimento WASD
        if keyboard.events[bge.events.WKEY] == bge.logic.KX_INPUT_ACTIVE:
            obj.applyMovement([0, speed, 0], True)
        if keyboard.events[bge.events.SKEY] == bge.logic.KX_INPUT_ACTIVE:
            obj.applyMovement([0, -speed, 0], True)
        if keyboard.events[bge.events.AKEY] == bge.logic.KX_INPUT_ACTIVE:
            obj.applyMovement([-speed, 0, 0], True)
        if keyboard.events[bge.events.DKEY] == bge.logic.KX_INPUT_ACTIVE:
            obj.applyMovement([speed, 0, 0], True)
    """
        create_text_script("player_move.py", move_script)
    
        sensors_info = [
            {'name': 'Always', 'type': 'ALWAYS', 'use_pulse_true_level': True}
        ]
        controllers_info = [
            {'name': 'PythonMove', 'type': 'PYTHON', 'script': 'player_move.py'}
        ]
        links_info = [{'sensor': 'Always', 'controller': 'PythonMove'}]
    
        setup_logic_bricks(player, sensors_info, controllers_info, links_info)
        return player
    
    def create_collectible(location=(3,0,1)):
        bpy.ops.mesh.primitive_ico_sphere_add(radius=0.5, location=location)
        coin = bpy.context.active_object
        coin.name = "Collectible"
        coin.game.use_collision_bounds = True
        coin.game.collision_bounds_type = 'SPHERE'
        coin.game.collision_group = 2  # Grupo colisão 2 (itens)
        coin.game.collision_mask = 1   # Detecta colisão com grupo 1 (player)
    
        collectible_script = """
    import bge
    
    def main(cont):
        own = cont.owner
        collision_sensor = cont.sensors['Collision']
        if collision_sensor.positive:
            own.endObject()
            print('Item coletado!')
    """
        create_text_script("collectible_logic.py", collectible_script)
    
        sensors_info = [
            {'name': 'Collision', 'type': 'COLLISION', 'collision_mask': 1, 'use_pulse_true_level': True}
        ]
        controllers_info = [
            {'name': 'PythonCollect', 'type': 'PYTHON', 'script': 'collectible_logic.py'}
        ]
        links_info = [{'sensor': 'Collision', 'controller': 'PythonCollect'}]
    
        setup_logic_bricks(coin, sensors_info, controllers_info, links_info)
        return coin
    
    def create_camera_follow(target):
        bpy.ops.object.camera_add(location=(0, -10, 5))
        cam = bpy.context.active_object
        cam.name = "GameCamera"
        cam.rotation_euler = (1.2, 0, 0)
    
        camera_script = """
    import bge
    
    def main(cont):
        cam = cont.owner
        scene = bge.logic.getCurrentScene()
        player = scene.objects.get('Player')
        if player:
            cam.position = player.position + [0, -10, 5]
            cam.lookAt(player)
    """
        create_text_script("camera_follow.py", camera_script)
    
        sensors_info = [
            {'name': 'Always', 'type': 'ALWAYS', 'use_pulse_true_level': True}
        ]
        controllers_info = [
            {'name': 'PythonCam', 'type': 'PYTHON', 'script': 'camera_follow.py'}
        ]
        links_info = [{'sensor': 'Always', 'controller': 'PythonCam'}]
    
        setup_logic_bricks(cam, sensors_info, controllers_info, links_info)
    
        return cam
    
    class UPBGEGAME_OT_create_game(bpy.types.Operator):
        bl_idname = "upbgegame.create_game"
        bl_label = "Criar mini jogo UPBGE"
        bl_description = "Cria uma cena básica com personagem, item colecionável e câmera com lógica"
        bl_options = {'REGISTER', 'UNDO'}
    
        def execute(self, context):
            # Deleta objetos da cena atual para limpar
            bpy.ops.object.select_all(action='SELECT')
            bpy.ops.object.delete(use_global=False)
    
            player = create_player()
            create_collectible(location=(3,0,1))
            create_collectible(location=(-3,2,1))
            create_camera_follow(player)
    
            self.report({'INFO'}, "Mini jogo criado! Pressione P para jogar.")
            return {'FINISHED'}
    
    class UPBGEGAME_PT_panel(bpy.types.Panel):
        bl_label = "UPBGE Mini Game"
        bl_idname = "UPBGEGAME_PT_panel"
        bl_space_type = 'VIEW_3D'
        bl_region_type = 'UI'
        bl_category = "UPBGE Game"
    
        def draw(self, context):
            layout = self.layout
            layout.operator("upbgegame.create_game", icon='GAME')
            layout.label(text="Clique para criar o mini jogo completo.")
    
    classes = (
        UPBGEGAME_OT_create_game,
        UPBGEGAME_PT_panel,
    )
    
    def register():
        for cls in classes:
            bpy.utils.register_class(cls)
    
    def unregister():
        for cls in reversed(classes):
            bpy.utils.unregister_class(cls)
    
    if __name__ == "__main__":
        register()
    

    Passos para usar o addon corrigido

    1. Salve este código em um arquivo .py (ex: upbge_game_creator.py).
    2. No Blender/UPBGE, vá em Edit > Preferences > Add-ons > Install..., selecione o arquivo e instale.
    3. Ative o addon.
    4. No 3D Viewport, pressione N para abrir a Sidebar.
    5. Procure a aba chamada UPBGE Game (última aba).
    6. Lá estará o botão Criar mini jogo UPBGE.
    7. Clique para limpar a cena e gerar o jogo básico.
    8. Pressione P para iniciar o jogo.

    Por que o código foi alterado?

    • Certifiquei que o painel tem bl_category definido corretamente (exato nome "UPBGE Game").
    • Adicionei nomes para sensores e controladores para evitar conflito.
    • Corrigi o método para limpar texto no Text Editor (txt.clear() antes de txt.write()).
    • Adicionei uma label explicativa no painel para garantir que está visível.
    • Garanti que a função register() é chamada ao executar como script.
    • Defini grupos de colisão (collision_group e collision_mask) para que sensores de colisão funcionem corretamente.
    • Usei propriedades corretas (use_pulse_true_level) para sensores Always.

    Se seguir esses passos e abrir a Sidebar no modo 3D View não aparecer a aba ou o botão, avise que verifico detalhes para você — mas com essa versão tudo deve funcionar direitinho.


    Estou à disposição para ajudar com outras funcionalidades para o UPBGE e seu workflow!

  17. User

    Python: Traceback (most recent call last): File "C:\Users\Gessu\AppData\Roaming\UPBGE\Blender\4.4\scripts\addons\upbge_game_creator.py", line 191, in draw layout.operator("upbgegame.create_game", icon='GAME') TypeError: UILayout.operator(): error with keyword argument "icon" - enum "GAME" not found in ('NONE', 'BLANK1', 'AUTOMERGE_OFF', 'AUTOMERGE_ON', 'CHECKBOX_DEHLT', 'CHECKBOX_HLT', 'CLIPUV_DEHLT', 'CLIPUV_HLT', 'DECORATE_UNLOCKED', 'DECORATE_LOCKED', 'FAKE_USER_OFF', 'FAKE_USER_ON', 'HIDE_ON', 'HIDE_OFF', 'INDIRECT_ONLY_OFF', 'INDIRECT_ONLY_ON', 'ONIONSKIN_OFF', 'ONIONSKIN_ON', 'UNPINNED', 'PINNED', 'RADIOBUT_OFF', 'RADIOBUT_ON', 'RECORD_OFF', 'RECORD_ON', 'RESTRICT_RENDER_ON', 'RESTRICT_RENDER_OFF', 'RESTRICT_SELECT_ON', 'RESTRICT_SELECT_OFF', 'RESTRICT_VIEW_ON', 'RESTRICT_VIEW_OFF', 'RIGHTARROW', 'DOWNARROW_HLT', 'SELECT_INTERSECT', 'SELECT_DIFFERENCE', 'SNAP_OFF', 'SNAP_ON', 'UNLOCKED', 'LOCKED', 'VIS_SEL_11', 'VIS_SEL_10', 'VIS_SEL_01', 'VIS_SEL_00', 'CANCEL', 'ERROR', 'QUESTION', 'ADD', 'ARROW_LEFTRIGHT', 'AUTO', 'BLENDER', 'BORDERMOVE', 'BRUSHES_ALL', 'CHECKMARK', 'COLLAPSEMENU', 'COLLECTION_NEW', 'COLOR', 'COPY_ID', 'DISCLOSURE_TRI_DOWN', 'DISCLOSURE_TRI_RIGHT', 'DOT', 'DRIVER_DISTANCE', 'DRIVER_ROTATIONAL_DIFFERENCE', 'DRIVER_TRANSFORM', 'DUPLICATE', 'EYEDROPPER', 'FCURVE_SNAPSHOT', 'FILE_NEW', 'FILE_TICK', 'FREEZE', 'FULLSCREEN_ENTER', 'FULLSCREEN_EXIT', 'GHOST_DISABLED', 'GHOST_ENABLED', 'GRIP', 'HAND', 'HELP', 'LINKED', 'MENU_PANEL', 'NODE_SEL', 'NODE', 'OBJECT_HIDDEN', 'OPTIONS', 'PANEL_CLOSE', 'PLUGIN', 'PLUS', 'PRESET_NEW', 'QUIT', 'RECOVER_LAST', 'REMOVE', 'RIGHTARROW_THIN', 'SCREEN_BACK', 'STATUSBAR', 'STYLUS_PRESSURE', 'THREE_DOTS', 'TOPBAR', 'TRASH', 'TRIA_DOWN', 'TRIA_LEFT', 'TRIA_RIGHT', 'TRIA_UP', 'UNLINKED', 'URL', 'VIEWZOOM', 'WINDOW', 'WORKSPACE', 'X', 'ZOOM_ALL', 'ZOOM_IN', 'ZOOM_OUT', 'ZOOM_PREVIOUS', 'ZOOM_SELECTED', 'MODIFIER', 'PARTICLES', 'PHYSICS', 'SHADERFX', 'SPEAKER', 'OUTPUT', 'SCENE', 'TOOL_SETTINGS', 'LIGHT', 'MATERIAL', 'TEXTURE', 'WORLD', 'ANIM', 'SCRIPT', 'GEOMETRY_NODES', 'TEXT', 'ACTION', 'ASSET_MANAGER', 'CONSOLE', 'FILEBROWSER', 'GEOMETRY_SET', 'GRAPH', 'IMAGE', 'INFO', 'LOGIC', 'NLA', 'NODE_COMPOSITING', 'NODE_MATERIAL', 'NODE_TEXTURE', 'NODETREE', 'OUTLINER', 'PREFERENCES', 'PROPERTIES', 'SEQUENCE', 'SOUND', 'SPREADSHEET', 'TIME', 'TRACKER', 'UV', 'VIEW3D', 'EDITMODE_HLT', 'OBJECT_DATAMODE', 'PARTICLEMODE', 'POSE_HLT', 'SCULPTMODE_HLT', 'TPAINT_HLT', 'UV_DATA', 'VPAINT_HLT', 'WPAINT_HLT', 'TRACKER_DATA', 'TRACKING_BACKWARDS_SINGLE', 'TRACKING_BACKWARDS', 'TRACKING_CLEAR_BACKWARDS', 'TRACKING_CLEAR_FORWARDS', 'TRACKING_FORWARDS_SINGLE', 'TRACKING_FORWARDS', 'TRACKING_REFINE_BACKWARDS', 'TRACKING_REFINE_FORWARDS', 'TRACKING', 'GROUP', 'CONSTRAINT_BONE', 'CONSTRAINT', 'ARMATURE_DATA', 'BONE_DATA', 'CAMERA_DATA', 'CURVE_DATA', 'EMPTY_DATA', 'FONT_DATA', 'LATTICE_DATA', 'LIGHT_DATA', 'MESH_DATA', 'META_DATA', 'PARTICLE_DATA', 'SHAPEKEY_DATA', 'SURFACE_DATA', 'OBJECT_DATA', 'RENDER_RESULT', 'RENDERLAYERS', 'SCENE_DATA', 'BRUSH_DATA', 'IMAGE_DATA', 'LINE_DATA', 'MATERIAL_DATA', 'TEXTURE_DATA', 'WORLD_DATA', 'ANIM_DATA', 'BOIDS', 'CAMERA_STEREO', 'COMMUNITY', 'FACE_MAPS', 'FCURVE', 'FILE', 'GREASEPENCIL', 'GREASEPENCIL_LAYER_GROUP', 'GROUP_BONE', 'GROUP_UVS', 'GROUP_VCOL', 'GROUP_VERTEX', 'LIBRARY_DATA_BROKEN', 'LIBRARY_DATA_DIRECT', 'LIBRARY_DATA_OVERRIDE', 'ORPHAN_DATA', 'PACKAGE', 'PRESET', 'RENDER_ANIMATION', 'RENDER_STILL', 'RNA_ADD', 'RNA', 'STRANDS', 'UGLYPACKAGE', 'MOUSE_LMB', 'MOUSE_MMB', 'MOUSE_RMB', 'MOUSE_MMB_SCROLL', 'MOUSE_LMB_2X', 'MOUSE_MOVE', 'MOUSE_LMB_DRAG', 'MOUSE_MMB_DRAG', 'MOUSE_RMB_DRAG', 'DECORATE_ANIMATE', 'DECORATE_DRIVER', 'DECORATE_KEYFRAME', 'DECORATE_LIBRARY_OVERRIDE', 'DECORATE_LINKED', 'DECORATE_OVERRIDE', 'DECORATE', 'OUTLINER_COLLECTION', 'CURVES_DATA', 'OUTLINER_DATA_ARMATURE', 'OUTLINER_DATA_CAMERA', 'OUTLINER_DATA_CURVE', 'OUTLINER_DATA_CURVES', 'OUTLINER_DATA_EMPTY', 'OUTLINER_DATA_FONT', 'OUTLINER_DATA_GP_LAYER', 'OUTLINER_DATA_GREASEPENCIL', 'OUTLINER_DATA_LATTICE', 'OUTLINER_DATA_LIGHT', 'OUTLINER_DATA_LIGHTPROBE', 'OUTLINER_DATA_MESH', 'OUTLINER_DATA_META', 'OUTLINER_DATA_POINTCLOUD', 'OUTLINER_DATA_SPEAKER', 'OUTLINER_DATA_SURFACE', 'OUTLINER_DATA_VOLUME', 'POINTCLOUD_DATA', 'POINTCLOUD_POINT', 'VOLUME_DATA', 'OUTLINER_OB_ARMATURE', 'OUTLINER_OB_CAMERA', 'OUTLINER_OB_CURVE', 'OUTLINER_OB_CURVES', 'OUTLINER_OB_EMPTY', 'OUTLINER_OB_FONT', 'OUTLINER_OB_FORCE_FIELD', 'OUTLINER_OB_GREASEPENCIL', 'OUTLINER_OB_GROUP_INSTANCE', 'OUTLINER_OB_IMAGE', 'OUTLINER_OB_LATTICE', 'OUTLINER_OB_LIGHT', 'OUTLINER_OB_LIGHTPROBE', 'OUTLINER_OB_MESH', 'OUTLINER_OB_META', 'OUTLINER_OB_POINTCLOUD', 'OUTLINER_OB_SPEAKER', 'OUTLINER_OB_SURFACE', 'OUTLINER_OB_VOLUME', 'GP_MULTIFRAME_EDITING', 'GP_ONLY_SELECTED', 'GP_SELECT_BETWEEN_STROKES', 'GP_SELECT_POINTS', 'GP_SELECT_STROKES', 'HOLDOUT_OFF', 'HOLDOUT_ON', 'MODIFIER_OFF', 'MODIFIER_ON', 'RESTRICT_COLOR_OFF', 'RESTRICT_COLOR_ON', 'RESTRICT_INSTANCED_OFF', 'RESTRICT_INSTANCED_ON', 'LIGHT_AREA', 'LIGHT_HEMI', 'LIGHT_POINT', 'LIGHT_SPOT', 'LIGHT_SUN', 'LIGHTPROBE_PLANE', 'LIGHTPROBE_SPHERE', 'LIGHTPROBE_VOLUME', 'COLOR_BLUE', 'COLOR_GREEN', 'COLOR_RED', 'CONE', 'CUBE', 'CURVE_BEZCIRCLE', 'CURVE_BEZCURVE', 'CURVE_NCIRCLE', 'CURVE_NCURVE', 'CURVE_PATH', 'CURVES', 'EMPTY_ARROWS', 'EMPTY_AXIS', 'EMPTY_SINGLE_ARROW', 'MESH_CAPSULE', 'MESH_CIRCLE', 'MESH_CONE', 'MESH_CUBE', 'MESH_CYLINDER', 'MESH_GRID', 'MESH_ICOSPHERE', 'MESH_MONKEY', 'MESH_PLANE', 'MESH_TORUS', 'MESH_UVSPHERE', 'META_BALL', 'META_CAPSULE', 'META_CUBE', 'META_ELLIPSOID', 'META_PLANE', 'MONKEY', 'SPHERE', 'STROKE', 'SURFACE_NCIRCLE', 'SURFACE_NCURVE', 'SURFACE_NCYLINDER', 'SURFACE_NSPHERE', 'SURFACE_NSURFACE', 'SURFACE_NTORUS', 'TRIA_DOWN_BAR', 'TRIA_LEFT_BAR', 'TRIA_RIGHT_BAR', 'TRIA_UP_BAR', 'AREA_DOCK', 'AREA_JOIN_DOWN', 'AREA_JOIN_LEFT', 'AREA_JOIN_UP', 'AREA_JOIN', 'AREA_SWAP', 'FORCE_BOID', 'FORCE_CHARGE', 'FORCE_CURVE', 'FORCE_DRAG', 'FORCE_FLUIDFLOW', 'FORCE_FORCE', 'FORCE_HARMONIC', 'FORCE_LENNARDJONES', 'FORCE_MAGNETIC', 'FORCE_TEXTURE', 'FORCE_TURBULENCE', 'FORCE_VORTEX', 'FORCE_WIND', 'IMAGE_BACKGROUND', 'IMAGE_PLANE', 'IMAGE_REFERENCE', 'RIGID_BODY_CONSTRAINT', 'RIGID_BODY', 'SPLIT_HORIZONTAL', 'SPLIT_VERTICAL', 'ANCHOR_BOTTOM', 'ANCHOR_CENTER', 'ANCHOR_LEFT', 'ANCHOR_RIGHT', 'ANCHOR_TOP', 'NODE_CORNER', 'NODE_INSERT_OFF', 'NODE_INSERT_ON', 'NODE_SIDE', 'NODE_TOP', 'SELECT_EXTEND', 'SELECT_SET', 'SELECT_SUBTRACT', 'ALIGN_BOTTOM', 'ALIGN_CENTER', 'ALIGN_FLUSH', 'ALIGN_JUSTIFY', 'ALIGN_LEFT', 'ALIGN_MIDDLE', 'ALIGN_RIGHT', 'ALIGN_TOP', 'BOLD', 'ITALIC', 'LINENUMBERS_OFF', 'LINENUMBERS_ON', 'SCRIPTPLUGINS', 'SMALL_CAPS', 'SYNTAX_OFF', 'SYNTAX_ON', 'UNDERLINE', 'WORDWRAP_OFF', 'WORDWRAP_ON', 'CON_ACTION', 'CON_ARMATURE', 'CON_CAMERASOLVER', 'CON_CHILDOF', 'CON_CLAMPTO', 'CON_DISTLIMIT', 'CON_FLOOR', 'CON_FOLLOWPATH', 'CON_FOLLOWTRACK', 'CON_KINEMATIC', 'CON_LOCKTRACK', 'CON_LOCLIKE', 'CON_LOCLIMIT', 'CON_OBJECTSOLVER', 'CON_PIVOT', 'CON_ROTLIKE', 'CON_ROTLIMIT', 'CON_SAMEVOL', 'CON_SHRINKWRAP', 'CON_SIZELIKE', 'CON_SIZELIMIT', 'CON_SPLINEIK', 'CON_STRETCHTO', 'CON_TRACKTO', 'CON_TRANSFORM_CACHE', 'CON_TRANSFORM', 'CON_TRANSLIKE', 'HOOK', 'MOD_ARMATURE', 'MOD_ARRAY', 'MOD_BEVEL', 'MOD_BOOLEAN', 'MOD_BUILD', 'MOD_CAST', 'MOD_CLOTH', 'MOD_CURVE', 'MOD_DASH', 'MOD_DATA_TRANSFER', 'MOD_DECIM', 'MOD_DISPLACE', 'MOD_DYNAMICPAINT', 'MOD_EDGESPLIT', 'MOD_ENVELOPE', 'MOD_EXPLODE', 'MOD_FLUID', 'MOD_FLUIDSIM', 'MOD_HUE_SATURATION', 'MOD_INSTANCE', 'MOD_LATTICE', 'MOD_LENGTH', 'MOD_LINEART', 'MOD_MASK', 'MOD_MESHDEFORM', 'MOD_MIRROR', 'MOD_MULTIRES', 'MOD_NOISE', 'MOD_NORMALEDIT', 'MOD_OCEAN', 'MOD_OFFSET', 'MOD_OPACITY', 'MOD_OUTLINE', 'MOD_PARTICLE_INSTANCE', 'MOD_PARTICLES', 'MOD_PHYSICS', 'MOD_REMESH', 'MOD_SCREW', 'MOD_SHRINKWRAP', 'MOD_SIMPLEDEFORM', 'MOD_SIMPLIFY', 'MOD_SKIN', 'MOD_SMOOTH', 'MOD_SOFT', 'MOD_SOLIDIFY', 'MOD_SUBSURF', 'MOD_THICKNESS', 'MOD_TIME', 'MOD_TINT', 'MOD_TRIANGULATE', 'MOD_UVPROJECT', 'MOD_VERTEX_WEIGHT', 'MOD_WARP', 'MOD_WAVE', 'MOD_WIREFRAME', 'MODIFIER_DATA', 'ACTION_SLOT', 'ACTION_TWEAK', 'DRIVER', 'FF', 'FRAME_NEXT', 'FRAME_PREV', 'HANDLE_ALIGNED', 'HANDLE_AUTO', 'HANDLE_AUTOCLAMPED', 'HANDLE_FREE', 'HANDLE_VECTOR', 'IPO_BACK', 'IPO_BEZIER', 'IPO_BOUNCE', 'IPO_CIRC', 'IPO_CONSTANT', 'IPO_CUBIC', 'IPO_EASE_IN_OUT', 'IPO_EASE_IN', 'IPO_EASE_OUT', 'IPO_ELASTIC', 'IPO_EXPO', 'IPO_LINEAR', 'IPO_QUAD', 'IPO_QUART', 'IPO_QUINT', 'IPO_SINE', 'KEY_DEHLT', 'KEY_HLT', 'KEYFRAME_HLT', 'KEYFRAME', 'KEYINGSET', 'MARKER_HLT', 'MARKER', 'MUTE_IPO_OFF', 'MUTE_IPO_ON', 'NEXT_KEYFRAME', 'NLA_PUSHDOWN', 'NORMALIZE_FCURVES', 'ORIENTATION_PARENT', 'PAUSE', 'PLAY_REVERSE', 'PLAY_SOUND', 'PLAY', 'PMARKER_ACT', 'PMARKER_SEL', 'PMARKER', 'PREV_KEYFRAME', 'PREVIEW_RANGE', 'REC', 'REW', 'SOLO_OFF', 'SOLO_ON', 'CENTER_ONLY', 'CURSOR', 'EDGESEL', 'FACE_CORNER', 'FACESEL', 'INVERSESQUARECURVE', 'LINCURVE', 'NOCURVE', 'PARTICLE_PATH', 'PARTICLE_POINT', 'PARTICLE_TIP', 'PIVOT_ACTIVE', 'PIVOT_BOUNDBOX', 'PIVOT_CURSOR', 'PIVOT_INDIVIDUAL', 'PIVOT_MEDIAN', 'PROP_CON', 'PROP_OFF', 'PROP_ON', 'PROP_PROJECTED', 'RNDCURVE', 'ROOTCURVE', 'SHARPCURVE', 'SMOOTHCURVE', 'SPHERECURVE', 'VERTEXSEL', 'SNAP_EDGE', 'SNAP_FACE_CENTER', 'SNAP_FACE_NEAREST', 'SNAP_FACE', 'SNAP_GRID', 'SNAP_INCREMENT', 'SNAP_MIDPOINT', 'SNAP_NORMAL', 'SNAP_PEEL_OBJECT', 'SNAP_PERPENDICULAR', 'SNAP_VERTEX', 'SNAP_VOLUME', 'STICKY_UVS_DISABLE', 'STICKY_UVS_LOC', 'STICKY_UVS_VERT', 'ORIENTATION_GIMBAL', 'ORIENTATION_GLOBAL', 'ORIENTATION_LOCAL', 'ORIENTATION_NORMAL', 'ORIENTATION_VIEW', 'COPYDOWN', 'FIXED_SIZE', 'GIZMO', 'GP_CAPS_FLAT', 'GP_CAPS_ROUND', 'NORMALS_FACE', 'NORMALS_VERTEX_FACE', 'NORMALS_VERTEX', 'OBJECT_ORIGIN', 'ORIENTATION_CURSOR', 'PASTEDOWN', 'PASTEFLIPDOWN', 'PASTEFLIPUP', 'TRANSFORM_ORIGINS', 'UV_EDGESEL', 'UV_FACESEL', 'UV_ISLANDSEL', 'UV_SYNC_SELECT', 'UV_VERTEXSEL', 'AXIS_FRONT', 'AXIS_SIDE', 'AXIS_TOP', 'GRID', 'LAYER_ACTIVE', 'LAYER_USED', 'LOCKVIEW_OFF', 'LOCKVIEW_ON', 'OVERLAY', 'SHADING_BBOX', 'SHADING_RENDERED', 'SHADING_SOLID', 'SHADING_TEXTURE', 'SHADING_WIRE', 'XRAY', 'VIEW_CAMERA_UNSELECTED', 'VIEW_CAMERA', 'VIEW_LOCKED', 'VIEW_ORTHO', 'VIEW_PAN', 'VIEW_PERSPECTIVE', 'VIEW_UNLOCKED', 'VIEW_ZOOM', 'FILE_ALIAS', 'FILE_FOLDER', 'FOLDER_REDIRECT', 'APPEND_BLEND', 'BACK', 'BOOKMARKS', 'CURRENT_FILE', 'DESKTOP', 'DISC', 'DISK_DRIVE', 'DOCUMENTS', 'EXPORT', 'EXTERNAL_DRIVE', 'FILE_3D', 'FILE_ARCHIVE', 'FILE_BACKUP', 'FILE_BLANK', 'FILE_BLEND', 'FILE_CACHE', 'FILE_FONT', 'FILE_HIDDEN', 'FILE_IMAGE', 'FILE_MOVIE', 'FILE_PARENT', 'FILE_REFRESH', 'FILE_SCRIPT', 'FILE_SOUND', 'FILE_TEXT', 'FILE_VOLUME', 'FILTER', 'FONTPREVIEW', 'FORWARD', 'HOME', 'IMGDISPLAY', 'IMPORT', 'LINK_BLEND', 'LONGDISPLAY', 'LOOP_BACK', 'LOOP_FORWARDS', 'NETWORK_DRIVE', 'NEWFOLDER', 'SETTINGS', 'SHORTDISPLAY', 'SORT_ASC', 'SORT_DESC', 'SORTALPHA', 'SORTBYEXT', 'SORTSIZE', 'SORTTIME', 'SYSTEM', 'TAG', 'TEMP', 'ALIASED', 'ANTIALIASED', 'MAT_SPHERE_SKY', 'MATCLOTH', 'MATCUBE', 'MATFLUID', 'MATPLANE', 'MATSHADERBALL', 'MATSPHERE', 'SEQ_CHROMA_SCOPE', 'SEQ_HISTOGRAM', 'SEQ_LUMA_WAVEFORM', 'SEQ_PREVIEW', 'SEQ_SEQUENCER', 'SEQ_SPLITVIEW', 'SEQ_STRIP_DUPLICATE', 'SEQ_STRIP_META', 'IMAGE_ALPHA', 'IMAGE_RGB_ALPHA', 'IMAGE_RGB', 'IMAGE_ZDEPTH', 'BLENDER_LOGO_LARGE', 'CANCEL_LARGE', 'DISC_LARGE', 'DISK_DRIVE_LARGE', 'EXTERNAL_DRIVE_LARGE', 'FILE_FOLDER_LARGE', 'FILE_LARGE', 'FILE_PARENT_LARGE', 'INFO_LARGE', 'NETWORK_DRIVE_LARGE', 'QUESTION_LARGE', 'WARNING_LARGE', 'KEY_BACKSPACE_FILLED', 'KEY_BACKSPACE', 'KEY_COMMAND_FILLED', 'KEY_COMMAND', 'KEY_CONTROL_FILLED', 'KEY_CONTROL', 'KEY_EMPTY1_FILLED', 'KEY_EMPTY1', 'KEY_EMPTY2_FILLED', 'KEY_EMPTY2', 'KEY_EMPTY3_FILLED', 'KEY_EMPTY3', 'KEY_MENU_FILLED', 'KEY_MENU', 'KEY_OPTION_FILLED', 'KEY_OPTION', 'KEY_RETURN_FILLED', 'KEY_RETURN', 'KEY_RING_FILLED', 'KEY_RING', 'KEY_SHIFT_FILLED', 'KEY_SHIFT', 'KEY_TAB_FILLED', 'KEY_TAB', 'KEY_WINDOWS_FILLED', 'KEY_WINDOWS', 'FUND', 'HEART', 'INTERNET_OFFLINE', 'INTERNET', 'USER', 'EXPERIMENTAL', 'MEMORY', 'KEYTYPE_KEYFRAME_VEC', 'KEYTYPE_BREAKDOWN_VEC', 'KEYTYPE_EXTREME_VEC', 'KEYTYPE_JITTER_VEC', 'KEYTYPE_MOVING_HOLD_VEC', 'KEYTYPE_GENERATED_VEC', 'HANDLETYPE_FREE_VEC', 'HANDLETYPE_ALIGNED_VEC', 'HANDLETYPE_VECTOR_VEC', 'HANDLETYPE_AUTO_VEC', 'HANDLETYPE_AUTO_CLAMP_VEC', 'COLORSET_01_VEC', 'COLORSET_02_VEC', 'COLORSET_03_VEC', 'COLORSET_04_VEC', 'COLORSET_05_VEC', 'COLORSET_06_VEC', 'COLORSET_07_VEC', 'COLORSET_08_VEC', 'COLORSET_09_VEC', 'COLORSET_10_VEC', 'COLORSET_11_VEC', 'COLORSET_12_VEC', 'COLORSET_13_VEC', 'COLORSET_14_VEC', 'COLORSET_15_VEC', 'COLORSET_16_VEC', 'COLORSET_17_VEC', 'COLORSET_18_VEC', 'COLORSET_19_VEC', 'COLORSET_20_VEC', 'COLLECTION_COLOR_01', 'COLLECTION_COLOR_02', 'COLLECTION_COLOR_03', 'COLLECTION_COLOR_04', 'COLLECTION_COLOR_05', 'COLLECTION_COLOR_06', 'COLLECTION_COLOR_07', 'COLLECTION_COLOR_08', 'STRIP_COLOR_01', 'STRIP_COLOR_02', 'STRIP_COLOR_03', 'STRIP_COLOR_04', 'STRIP_COLOR_05', 'STRIP_COLOR_06', 'STRIP_COLOR_07', 'STRIP_COLOR_08', 'STRIP_COLOR_09', 'LIBRARY_DATA_INDIRECT', 'LIBRARY_DATA_OVERRIDE_NONEDITABLE', 'LAYERGROUP_COLOR_01', 'LAYERGROUP_COLOR_02', 'LAYERGROUP_COLOR_03', 'LAYERGROUP_COLOR_04', 'LAYERGROUP_COLOR_05', 'LAYERGROUP_COLOR_06', 'LAYERGROUP_COLOR_07', 'LAYERGROUP_COLOR_08', 'EVENT_A', 'EVENT_B', 'EVENT_C', 'EVENT_D', 'EVENT_E', 'EVENT_F', 'EVENT_G', 'EVENT_H', 'EVENT_I', 'EVENT_J', 'EVENT_K', 'EVENT_L', 'EVENT_M', 'EVENT_N', 'EVENT_O', 'EVENT_P', 'EVENT_Q', 'EVENT_R', 'EVENT_S', 'EVENT_T', 'EVENT_U', 'EVENT_V', 'EVENT_W', 'EVENT_X', 'EVENT_Y', 'EVENT_Z', 'EVENT_SHIFT', 'EVENT_CTRL', 'EVENT_ALT', 'EVENT_OS', 'EVENT_F1', 'EVENT_F2', 'EVENT_F3', 'EVENT_F4', 'EVENT_F5', 'EVENT_F6', 'EVENT_F7', 'EVENT_F8', 'EVENT_F9', 'EVENT_F10', 'EVENT_F11', 'EVENT_F12', 'EVENT_F13', 'EVENT_F14', 'EVENT_F15', 'EVENT_F16', 'EVENT_F17', 'EVENT_F18', 'EVENT_F19', 'EVENT_F20', 'EVENT_F21', 'EVENT_F22', 'EVENT_F23', 'EVENT_F24', 'EVENT_ESC', 'EVENT_TAB', 'EVENT_PAGEUP', 'EVENT_PAGEDOWN', 'EVENT_RETURN', 'EVENT_SPACEKEY', 'EVENT_ZEROKEY', 'EVENT_ONEKEY', 'EVENT_TWOKEY', 'EVENT_THREEKEY', 'EVENT_FOURKEY', 'EVENT_FIVEKEY', 'EVENT_SIXKEY', 'EVENT_SEVENKEY', 'EVENT_EIGHTKEY', 'EVENT_NINEKEY', 'EVENT_PAD0', 'EVENT_PAD1', 'EVENT_PAD2', 'EVENT_PAD3', 'EVENT_PAD4', 'EVENT_PAD5', 'EVENT_PAD6', 'EVENT_PAD7', 'EVENT_PAD8', 'EVENT_PAD9', 'EVENT_PADASTER', 'EVENT_PADSLASH', 'EVENT_PADMINUS', 'EVENT_PADENTER', 'EVENT_PADPLUS', 'EVENT_PADPERIOD', 'EVENT_MOUSE_4', 'EVENT_MOUSE_5', 'EVENT_MOUSE_6', 'EVENT_MOUSE_7', 'EVENT_TABLET_STYLUS', 'EVENT_TABLET_ERASER', 'EVENT_LEFT_ARROW', 'EVENT_DOWN_ARROW', 'EVENT_RIGHT_ARROW', 'EVENT_UP_ARROW', 'EVENT_PAUSE', 'EVENT_INSERT', 'EVENT_HOME', 'EVENT_END', 'EVENT_UNKNOWN', 'EVENT_GRLESS', 'EVENT_MEDIAPLAY', 'EVENT_MEDIASTOP', 'EVENT_MEDIAFIRST', 'EVENT_MEDIALAST', 'EVENT_APP', 'EVENT_CAPSLOCK', 'EVENT_BACKSPACE', 'EVENT_DEL', 'EVENT_SEMICOLON', 'EVENT_PERIOD', 'EVENT_COMMA', 'EVENT_QUOTE', 'EVENT_ACCENTGRAVE', 'EVENT_MINUS', 'EVENT_PLUS', 'EVENT_SLASH', 'EVENT_BACKSLASH', 'EVENT_EQUAL', 'EVENT_LEFTBRACKET', 'EVENT_RIGHTBRACKET', 'EVENT_NDOF_BUTTON_V1', 'EVENT_NDOF_BUTTON_V2', 'EVENT_NDOF_BUTTON_V3', 'EVENT_NDOF_BUTTON_SAVE_V1', 'EVENT_NDOF_BUTTON_SAVE_V2', 'EVENT_NDOF_BUTTON_SAVE_V3', 'EVENT_NDOF_BUTTON_1', 'EVENT_NDOF_BUTTON_2', 'EVENT_NDOF_BUTTON_3', 'EVENT_NDOF_BUTTON_4', 'EVENT_NDOF_BUTTON_5', 'EVENT_NDOF_BUTTON_6', 'EVENT_NDOF_BUTTON_7', 'EVENT_NDOF_BUTTON_8', 'EVENT_NDOF_BUTTON_9', 'EVENT_NDOF_BUTTON_10', 'EVENT_NDOF_BUTTON_11', 'EVENT_NDOF_BUTTON_12', 'EVENT_NDOF_BUTTON_MENU', 'EVENT_NDOF_BUTTON_FIT', 'EVENT_NDOF_BUTTON_TOP', 'EVENT_NDOF_BUTTON_BOTTOM', 'EVENT_NDOF_BUTTON_LEFT', 'EVENT_NDOF_BUTTON_RIGHT', 'EVENT_NDOF_BUTTON_FRONT', 'EVENT_NDOF_BUTTON_BACK', 'EVENT_NDOF_BUTTON_ISO1', 'EVENT_NDOF_BUTTON_ISO2', 'EVENT_NDOF_BUTTON_ROLL_CW', 'EVENT_NDOF_BUTTON_ROLL_CCW', 'EVENT_NDOF_BUTTON_SPIN_CW', 'EVENT_NDOF_BUTTON_SPIN_CCW', 'EVENT_NDOF_BUTTON_TILT_CW', 'EVENT_NDOF_BUTTON_TILT_CCW', 'EVENT_NDOF_BUTTON_ROTATE', 'EVENT_NDOF_BUTTON_PANZOOM', 'EVENT_NDOF_BUTTON_DOMINANT', 'EVENT_NDOF_BUTTON_PLUS', 'EVENT_NDOF_BUTTON_MINUS')

  18. Assistant

    O erro ocorre porque o ícone 'GAME' que você está tentando usar no layout.operator() não é um ícone válido na versão do Blender / UPBGE que está usando. A lista de ícones válidos é restrita e depende da versão, e 'GAME' não consta nela.


    Como corrigir

    Remova ou troque o ícone 'GAME' por algum que exista na sua versão.

    Exemplo:

    layout.operator("upbgegame.create_game", icon='PLAY')  # 'PLAY' normalmente existe
    

    Ou apenas sem ícone:

    layout.operator("upbgegame.create_game")
    

    Ícones comuns e seguros para usar:

    • 'PLAY' (botão play)
    • 'QUESTION'
    • 'INFO'
    • 'CHECKMARK'
    • 'ADD'
    • 'REMOVE'
    • 'ERROR'
    • 'WORLD'
    • 'MESH_CUBE'
    • 'CAMERA_DATA'

    Você pode usar algum deles para testar e escolher o que preferir.


    Trecho corrigido do seu painel:

    def draw(self, context):
        layout = self.layout
        layout.operator("upbgegame.create_game", icon='PLAY')  # troquei 'GAME' por 'PLAY'
        layout.label(text="Clique para criar o mini jogo completo.")
    

    Dica adicional — listar todos ícones possíveis no Blender

    Se quiser ver os ícones que sua versão do Blender/UPBGE suporta, rode este snippet no Text Editor (ele vai mostrar o nome dos ícones no console):

    import bpy
    
    for icon in dir(bpy.types.UILayout):
        if icon.startswith("icon_"):
            print(icon)
    

    (Na realidade, Blender não tem lista oficial fácil, mas a lista que causou seu erro foi impressa — pode escolher entre elas).


    Se corrigir esse ícone, o erro desaparecerá e o painel será exibido normalmente.


    Se precisar, posso enviar o código corrigido completo, só avisar!

  19. User

    sim

  20. Assistant

    Claro! Aqui está o addon completo corrigido, com o ícone icon='PLAY' que é seguro e disponível, para evitar erro:

    bl_info = {
        "name": "UPBGE Mini Game Creator",
        "author": "Seu Nome",
        "version": (1, 0, 0),
        "blender": (2, 80, 0),
        "location": "View3D > Sidebar > UPBGE Game",
        "description": "Cria uma cena com lógica básica de jogo (movimento, coleta, câmera)",
        "category": "Game Engine"
    }
    
    import bpy
    
    def create_text_script(script_name, script_code):
        txt = bpy.data.texts.get(script_name)
        if txt is None:
            txt = bpy.data.texts.new(script_name)
        else:
            txt.clear()
        txt.write(script_code)
        return txt
    
    def setup_logic_bricks(obj, sensors_info, controllers_info, links_info):
        sensors = obj.game.sensors
        controllers = obj.game.controllers
        while sensors:
            sensors.remove(sensors[0])
        while controllers:
            controllers.remove(controllers[0])
        
        sens = {}
        conts = {}
    
        for s in sensors_info:
            sens_obj = sensors.new(type=s['type'])
            sens_obj.name = s.get('name', sens_obj.name)
            for prop, val in s.items():
                if prop not in ['type', 'name']:
                    setattr(sens_obj, prop, val)
            sens[s['name']] = sens_obj
    
        for c in controllers_info:
            cont_obj = controllers.new(type=c['type'])
            cont_obj.name = c.get('name', cont_obj.name)
            for prop, val in c.items():
                if prop not in ['type', 'script', 'name']:
                    setattr(cont_obj, prop, val)
            if 'script' in c:
                cont_obj.mode = 'SCRIPT'
                cont_obj.script = c['script']
            conts[c['name']] = cont_obj
    
        for link in links_info:
            s_name = link['sensor']
            c_name = link['controller']
            if s_name in sens and c_name in conts:
                conts[c_name].link(sens[s_name])
    
    def create_player():
        bpy.ops.mesh.primitive_cube_add(size=1)
        player = bpy.context.active_object
        player.name = "Player"
        player.location = (0, 0, 1)
        player.game.use_collision_bounds = True
        player.game.collision_bounds_type = 'BOX'
        player.game.collision_group = 1  # Grupo de colisão 1
        player.game.collision_mask = 2   # Detecta colisões com grupo 2 (itens)
    
        move_script = """
    import bge
    
    def main(cont):
        obj = cont.owner
        keyboard = bge.logic.keyboard
        speed = 0.1
        from bge import events
    
        if keyboard.events[bge.events.WKEY] == bge.logic.KX_INPUT_ACTIVE:
            obj.applyMovement([0, speed, 0], True)
        if keyboard.events[bge.events.SKEY] == bge.logic.KX_INPUT_ACTIVE:
            obj.applyMovement([0, -speed, 0], True)
        if keyboard.events[bge.events.AKEY] == bge.logic.KX_INPUT_ACTIVE:
            obj.applyMovement([-speed, 0, 0], True)
        if keyboard.events[bge.events.DKEY] == bge.logic.KX_INPUT_ACTIVE:
            obj.applyMovement([speed, 0, 0], True)
    """
        create_text_script("player_move.py", move_script)
    
        sensors_info = [
            {'name': 'Always', 'type': 'ALWAYS', 'use_pulse_true_level': True}
        ]
        controllers_info = [
            {'name': 'PythonMove', 'type': 'PYTHON', 'script': 'player_move.py'}
        ]
        links_info = [{'sensor': 'Always', 'controller': 'PythonMove'}]
    
        setup_logic_bricks(player, sensors_info, controllers_info, links_info)
        return player
    
    def create_collectible(location=(3,0,1)):
        bpy.ops.mesh.primitive_ico_sphere_add(radius=0.5, location=location)
        coin = bpy.context.active_object
        coin.name = "Collectible"
        coin.game.use_collision_bounds = True
        coin.game.collision_bounds_type = 'SPHERE'
        coin.game.collision_group = 2  # Grupo colisão 2 (itens)
        coin.game.collision_mask = 1   # Detecta colisão com grupo 1 (player)
    
        collectible_script = """
    import bge
    
    def main(cont):
        own = cont.owner
        collision_sensor = cont.sensors['Collision']
        if collision_sensor.positive:
            own.endObject()
            print('Item coletado!')
    """
        create_text_script("collectible_logic.py", collectible_script)
    
        sensors_info = [
            {'name': 'Collision', 'type': 'COLLISION', 'collision_mask': 1, 'use_pulse_true_level': True}
        ]
        controllers_info = [
            {'name': 'PythonCollect', 'type': 'PYTHON', 'script': 'collectible_logic.py'}
        ]
        links_info = [{'sensor': 'Collision', 'controller': 'PythonCollect'}]
    
        setup_logic_bricks(coin, sensors_info, controllers_info, links_info)
        return coin
    
    def create_camera_follow(target):
        bpy.ops.object.camera_add(location=(0, -10, 5))
        cam = bpy.context.active_object
        cam.name = "GameCamera"
        cam.rotation_euler = (1.2, 0, 0)
    
        camera_script = """
    import bge
    
    def main(cont):
        cam = cont.owner
        scene = bge.logic.getCurrentScene()
        player = scene.objects.get('Player')
        if player:
            cam.position = player.position + [0, -10, 5]
            cam.lookAt(player)
    """
        create_text_script("camera_follow.py", camera_script)
    
        sensors_info = [
            {'name': 'Always', 'type': 'ALWAYS', 'use_pulse_true_level': True}
        ]
        controllers_info = [
            {'name': 'PythonCam', 'type': 'PYTHON', 'script': 'camera_follow.py'}
        ]
        links_info = [{'sensor': 'Always', 'controller': 'PythonCam'}]
    
        setup_logic_bricks(cam, sensors_info, controllers_info, links_info)
    
        return cam
    
    class UPBGEGAME_OT_create_game(bpy.types.Operator):
        bl_idname = "upbgegame.create_game"
        bl_label = "Criar mini jogo UPBGE"
        bl_description = "Cria uma cena básica com personagem, item colecionável e câmera com lógica"
        bl_options = {'REGISTER', 'UNDO'}
    
        def execute(self, context):
            bpy.ops.object.select_all(action='SELECT')
            bpy.ops.object.delete(use_global=False)
    
            player = create_player()
            create_collectible(location=(3,0,1))
            create_collectible(location=(-3,2,1))
            create_camera_follow(player)
    
            self.report({'INFO'}, "Mini jogo criado! Pressione P para jogar.")
            return {'FINISHED'}
    
    class UPBGEGAME_PT_panel(bpy.types.Panel):
        bl_label = "UPBGE Mini Game"
        bl_idname = "UPBGEGAME_PT_panel"
        bl_space_type = 'VIEW_3D'
        bl_region_type = 'UI'
        bl_category = "UPBGE Game"
    
        def draw(self, context):
            layout = self.layout
            layout.operator("upbgegame.create_game", icon='PLAY')
            layout.label(text="Clique para criar o mini jogo completo.")
    
    classes = (
        UPBGEGAME_OT_create_game,
        UPBGEGAME_PT_panel,
    )
    
    def register():
        for cls in classes:
            bpy.utils.register_class(cls)
    
    def unregister():
        for cls in reversed(classes):
            bpy.utils.unregister_class(cls)
    
    if __name__ == "__main__":
        register()
    

    Passos para usar:

    1. Salve como upbge_game_creator.py
    2. Instale no Blender/UPBGE via Edit > Preferences > Add-ons > Install...
    3. Ative o addon.
    4. No 3D View, pressione N para abrir o Sidebar.
    5. Vá na aba UPBGE Game (última aba).
    6. Clique no botão Criar mini jogo UPBGE.
    7. A cena será criada com o player, objetos para coletar e câmera configurada.
    8. Pressione P para testar no UPBGE!

    Se precisar de mais ajuda ou quiser expandir a lógica, pode pedir!

  21. User

    Python: Traceback (most recent call last): File "C:\Users\Gessu\AppData\Roaming\UPBGE\Blender\4.4\scripts\addons\bupbge_game_creator.py", line 172, in execute player = create_player() ^^^^^^^^^^^^^^^ File "C:\Users\Gessu\AppData\Roaming\UPBGE\Blender\4.4\scripts\addons\bupbge_game_creator.py", line 65, in create_player player.game.collision_group = 1 # Grupo de colisão 1 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ValueError: bpy_struct: item.attr = val: sequence expected at dimension 1, not 'int'

  22. Assistant

    O erro

    ValueError: bpy_struct: item.attr = val: sequence expected at dimension 1, not 'int'
    

    está acontecendo porque a propriedade collision_group (e também collision_mask) em objetos UPBGE espera uma sequência (lista ou tupla) de 16 booleanos representando ativação/desativação dos 16 bits de grupos, e não um inteiro único.


    Como corrigir

    Definir collision_group e collision_mask corretamente

    Você deve passar uma lista/tupla com 16 valores booleanos (True/False), onde cada posição representa um grupo.

    Por exemplo:

    Se quiser ativar apenas o grupo 1 (bit 0), a lista é:

    ( True, False, False, False, False, False, False, False,
      False, False, False, False, False, False, False, False )
    

    Se quiser ativar grupo 1 e 2 (bits 0 e 1):

    ( True, True, False, False, False, False, False, False,
      False, False, False, False, False, False, False, False )
    

    Ajuste nas funções create_player() e create_collectible() para corrigir:

    Em create_player():

    player.game.collision_group = (True, False, False, False, False, False, False, False,
                                  False, False, False, False, False, False, False, False)
    player.game.collision_mask = (False, True, False, False, False, False, False, False,
                                 False, False, False, False, False, False, False, False)
    

    Em create_collectible():

    coin.game.collision_group = (False, True, False, False, False, False, False, False,
                                False, False, False, False, False, False, False, False)
    coin.game.collision_mask = (True, False, False, False, False, False, False, False,
                               False, False, False, False, False, False, False, False)
    

    Código corrigido para essas linhas:

    def create_player():
        bpy.ops.mesh.primitive_cube_add(size=1)
        player = bpy.context.active_object
        player.name = "Player"
        player.location = (0, 0, 1)
        player.game.use_collision_bounds = True
        player.game.collision_bounds_type = 'BOX'
        # Ativando grupo 1 (bit 0)
        player.game.collision_group = (True, False, False, False, False, False, False, False,
                                      False, False, False, False, False, False, False, False)
        # Detecta colisão com grupo 2 (bit 1)
        player.game.collision_mask = (False, True, False, False, False, False, False, False,
                                     False, False, False, False, False, False, False, False)
        # resto do código...
    
    def create_collectible(location=(3,0,1)):
        bpy.ops.mesh.primitive_ico_sphere_add(radius=0.5, location=location)
        coin = bpy.context.active_object
        coin.name = "Collectible"
        coin.game.use_collision_bounds = True
        coin.game.collision_bounds_type = 'SPHERE'
        # Ativando grupo 2 (bit 1)
        coin.game.collision_group = (False, True, False, False, False, False, False, False,
                                    False, False, False, False, False, False, False, False)
        # Detecta colisão com grupo 1 (bit 0)
        coin.game.collision_mask = (True, False, False, False, False, False, False, False,
                                   False, False, False, False, False, False, False, False)
        # resto do código...
    

    Isso deve eliminar o erro e permitir o funcionamento correto das colisões no UPBGE.

    Se quiser, posso te enviar o arquivo completo com essa correção aplicada. Quer?

  23. User

    sim

  24. Assistant

    Aqui está o addon completo corrigido com o ajuste correto das flags collision_group e collision_mask como tuplas de booleanos, para funcionar no UPBGE sem o erro citado:

    bl_info = {
        "name": "UPBGE Mini Game Creator",
        "author": "Seu Nome",
        "version": (1, 0, 0),
        "blender": (2, 80, 0),
        "location": "View3D > Sidebar > UPBGE Game",
        "description": "Cria uma cena com lógica básica de jogo (movimento, coleta, câmera)",
        "category": "Game Engine"
    }
    
    import bpy
    
    def create_text_script(script_name, script_code):
        txt = bpy.data.texts.get(script_name)
        if txt is None:
            txt = bpy.data.texts.new(script_name)
        else:
            txt.clear()
        txt.write(script_code)
        return txt
    
    def setup_logic_bricks(obj, sensors_info, controllers_info, links_info):
        sensors = obj.game.sensors
        controllers = obj.game.controllers
        while sensors:
            sensors.remove(sensors[0])
        while controllers:
            controllers.remove(controllers[0])
        
        sens = {}
        conts = {}
    
        for s in sensors_info:
            sens_obj = sensors.new(type=s['type'])
            sens_obj.name = s.get('name', sens_obj.name)
            for prop, val in s.items():
                if prop not in ['type', 'name']:
                    setattr(sens_obj, prop, val)
            sens[s['name']] = sens_obj
    
        for c in controllers_info:
            cont_obj = controllers.new(type=c['type'])
            cont_obj.name = c.get('name', cont_obj.name)
            for prop, val in c.items():
                if prop not in ['type', 'script', 'name']:
                    setattr(cont_obj, prop, val)
            if 'script' in c:
                cont_obj.mode = 'SCRIPT'
                cont_obj.script = c['script']
            conts[c['name']] = cont_obj
    
        for link in links_info:
            s_name = link['sensor']
            c_name = link['controller']
            if s_name in sens and c_name in conts:
                conts[c_name].link(sens[s_name])
    
    def create_player():
        bpy.ops.mesh.primitive_cube_add(size=1)
        player = bpy.context.active_object
        player.name = "Player"
        player.location = (0, 0, 1)
        player.game.use_collision_bounds = True
        player.game.collision_bounds_type = 'BOX'
        # Ativa apenas o grupo 1 (bit 0)
        player.game.collision_group = (True, False, False, False, False, False, False, False,
                                      False, False, False, False, False, False, False, False)
        # Detecta colisão com grupo 2 (bit 1)
        player.game.collision_mask = (False, True, False, False, False, False, False, False,
                                     False, False, False, False, False, False, False, False)
    
        move_script = """
    import bge
    
    def main(cont):
        obj = cont.owner
        keyboard = bge.logic.keyboard
        speed = 0.1
        from bge import events
    
        if keyboard.events[bge.events.WKEY] == bge.logic.KX_INPUT_ACTIVE:
            obj.applyMovement([0, speed, 0], True)
        if keyboard.events[bge.events.SKEY] == bge.logic.KX_INPUT_ACTIVE:
            obj.applyMovement([0, -speed, 0], True)
        if keyboard.events[bge.events.AKEY] == bge.logic.KX_INPUT_ACTIVE:
            obj.applyMovement([-speed, 0, 0], True)
        if keyboard.events[bge.events.DKEY] == bge.logic.KX_INPUT_ACTIVE:
            obj.applyMovement([speed, 0, 0], True)
    """
        create_text_script("player_move.py", move_script)
    
        sensors_info = [
            {'name': 'Always', 'type': 'ALWAYS', 'use_pulse_true_level': True}
        ]
        controllers_info = [
            {'name': 'PythonMove', 'type': 'PYTHON', 'script': 'player_move.py'}
        ]
        links_info = [{'sensor': 'Always', 'controller': 'PythonMove'}]
    
        setup_logic_bricks(player, sensors_info, controllers_info, links_info)
        return player
    
    def create_collectible(location=(3,0,1)):
        bpy.ops.mesh.primitive_ico_sphere_add(radius=0.5, location=location)
        coin = bpy.context.active_object
        coin.name = "Collectible"
        coin.game.use_collision_bounds = True
        coin.game.collision_bounds_type = 'SPHERE'
        # Ativa apenas o grupo 2 (bit 1)
        coin.game.collision_group = (False, True, False, False, False, False, False, False,
                                    False, False, False, False, False, False, False, False)
        # Detecta colisão com grupo 1 (bit 0)
        coin.game.collision_mask = (True, False, False, False, False, False, False, False,
                                   False, False, False, False, False, False, False, False)
    
        collectible_script = """
    import bge
    
    def main(cont):
        own = cont.owner
        collision_sensor = cont.sensors['Collision']
        if collision_sensor.positive:
            own.endObject()
            print('Item coletado!')
    """
        create_text_script("collectible_logic.py", collectible_script)
    
        sensors_info = [
            {'name': 'Collision', 'type': 'COLLISION', 'collision_mask': 1, 'use_pulse_true_level': True}
        ]
        controllers_info = [
            {'name': 'PythonCollect', 'type': 'PYTHON', 'script': 'collectible_logic.py'}
        ]
        links_info = [{'sensor': 'Collision', 'controller': 'PythonCollect'}]
    
        setup_logic_bricks(coin, sensors_info, controllers_info, links_info)
        return coin
    
    def create_camera_follow(target):
        bpy.ops.object.camera_add(location=(0, -10, 5))
        cam = bpy.context.active_object
        cam.name = "GameCamera"
        cam.rotation_euler = (1.2, 0, 0)
    
        camera_script = """
    import bge
    
    def main(cont):
        cam = cont.owner
        scene = bge.logic.getCurrentScene()
        player = scene.objects.get('Player')
        if player:
            cam.position = player.position + [0, -10, 5]
            cam.lookAt(player)
    """
        create_text_script("camera_follow.py", camera_script)
    
        sensors_info = [
            {'name': 'Always', 'type': 'ALWAYS', 'use_pulse_true_level': True}
        ]
        controllers_info = [
            {'name': 'PythonCam', 'type': 'PYTHON', 'script': 'camera_follow.py'}
        ]
        links_info = [{'sensor': 'Always', 'controller': 'PythonCam'}]
    
        setup_logic_bricks(cam, sensors_info, controllers_info, links_info)
    
        return cam
    
    class UPBGEGAME_OT_create_game(bpy.types.Operator):
        bl_idname = "upbgegame.create_game"
        bl_label = "Criar mini jogo UPBGE"
        bl_description = "Cria uma cena básica com personagem, item colecionável e câmera com lógica"
        bl_options = {'REGISTER', 'UNDO'}
    
        def execute(self, context):
            bpy.ops.object.select_all(action='SELECT')
            bpy.ops.object.delete(use_global=False)
    
            player = create_player()
            create_collectible(location=(3,0,1))
            create_collectible(location=(-3,2,1))
            create_camera_follow(player)
    
            self.report({'INFO'}, "Mini jogo criado! Pressione P para jogar.")
            return {'FINISHED'}
    
    class UPBGEGAME_PT_panel(bpy.types.Panel):
        bl_label = "UPBGE Mini Game"
        bl_idname = "UPBGEGAME_PT_panel"
        bl_space_type = 'VIEW_3D'
        bl_region_type = 'UI'
        bl_category = "UPBGE Game"
    
        def draw(self, context):
            layout = self.layout
            layout.operator("upbgegame.create_game", icon='PLAY')
            layout.label(text="Clique para criar o mini jogo completo.")
    
    classes = (
        UPBGEGAME_OT_create_game,
        UPBGEGAME_PT_panel,
    )
    
    def register():
        for cls in classes:
            bpy.utils.register_class(cls)
    
    def unregister():
        for cls in reversed(classes):
            bpy.utils.unregister_class(cls)
    
    if __name__ == "__main__":
        register()
    

    Passos para usar:

    1. Salve o arquivo upbge_game_creator.py
    2. No Blender/UPBGE, vá em Edit > Preferences > Add-ons > Install... e selecione este arquivo.
    3. Ative o addon.
    4. No 3D View, pressione N para abrir a Sidebar.
    5. Encontre a aba UPBGE Game e clique em Criar mini jogo UPBGE.
    6. A cena será criada com player, itens colecionáveis e câmera com lógica.
    7. Pressione P para iniciar o jogo.

    Qualquer dúvida ou se quiser expandir a funcionalidade pode chamar!

  25. User

    Python: Traceback (most recent call last): File "C:\Users\Gessu\AppData\Roaming\UPBGE\Blender\4.4\scripts\addons\cupbge_game_creator.py", line 180, in execute player = create_player() ^^^^^^^^^^^^^^^ File "C:\Users\Gessu\AppData\Roaming\UPBGE\Blender\4.4\scripts\addons\cupbge_game_creator.py", line 100, in create_player setup_logic_bricks(player, sensors_info, controllers_info, links_info) File "C:\Users\Gessu\AppData\Roaming\UPBGE\Blender\4.4\scripts\addons\cupbge_game_creator.py", line 34, in setup_logic_bricks sens_obj = sensors.new(type=s['type']) ^^^^^^^^^^^ AttributeError: bpy_prop_collection: attribute "new" not found

  26. Assistant

    O erro

    AttributeError: bpy_prop_collection: attribute "new" not found
    

    indica que o objeto obj.game.sensors (e obj.game.controllers) não possuem o método new() para criar sensores e controladores via API Python no Blender 2.8+ (ou UPBGE 0.3x+ / Blender 2.8+).


    Explicação

    • A API do Blender mudou, e o sistema de Logic Bricks não expõe uma função new() para criar sensores e controllers via script Python.
    • Ou seja, não é possível criar Logic Bricks diretamente no Blender via API Python assim como se fazia no Blender Game Engine original (2.79 ou anterior).

    O que pode ser feito no UPBGE 0.3+ e Blender 2.8+?

    1. Criar objetos com dados básicos e atribuir scripts e sensores manualmente (via interface).

    2. Automatizar criação de scripts (Text Editor) e configurar esses scripts para controllers, mas configurar logic bricks via script não é suportado diretamente em Python.


    Alternativas:

    • Automatizar a criação dos scripts no Text Editor (já fazemos).
    • Documentar para o usuário criar os logic bricks, ou criar um template .blend com a lógica pronta para duplicar.
    • Esperar que futuramente a API permita manipular Logic Bricks (não há previsão clara).
    • Conversar com a comunidade UPBGE se há addons ou ferramentas específicas para isso.

    O que significa para seu addon?

    • Você não conseguirá (no momento) criar sensores e controllers via script, só objetos e scripts Python.
    • Pode gerar objetos, criar scripts, associar propriedades em objetos, mas lógica deve ser configurada manualmente ou via templates.

    Sugestão de abordagem para seu addon

    • Crie o objeto.
    • Crie os scripts necessários (Text Editor).
    • Exiba instruções / alertas para o usuário vincular os logic bricks manualmente.
    • Ou forneça um arquivo .blend básico com tudo configurado, e o addon só duplica objetos.

    Por exemplo, criando o objeto e scripts (sem tentar criar logic bricks):

    def create_player():
        bpy.ops.mesh.primitive_cube_add(size=1)
        player = bpy.context.active_object
        player.name = "Player"
        player.location = (0, 0, 1)
        # Não tente acessar player.game.sensors.new() aqui pois não existe!
        create_text_script("player_move.py", '''
    import bge
    def main(cont):
        obj = cont.owner
        keyboard = bge.logic.keyboard
        speed = 0.1
        from bge import events
    
        if keyboard.events[bge.events.WKEY] == bge.logic.KX_INPUT_ACTIVE:
            obj.applyMovement([0, speed, 0], True)
        if keyboard.events[bge.events.SKEY] == bge.logic.KX_INPUT_ACTIVE:
            obj.applyMovement([0, -speed, 0], True)
        if keyboard.events[bge.events.AKEY] == bge.logic.KX_INPUT_ACTIVE:
            obj.applyMovement([-speed, 0, 0], True)
        if keyboard.events[bge.events.DKEY] == bge.logic.KX_INPUT_ACTIVE:
            obj.applyMovement([speed, 0, 0], True)
    ''')
        return player
    

    Resumo

    • API do Blender/UPBGE atual NÃO suporta criação de sensores/controllers via script!
    • É inevitável configurar logic bricks manualmente.
    • Seu addon pode criar objetos, scripts, materiais etc, mas wiring dos logic bricks tem que manualmente ou via duplicação de arquivos .blend.

    Se desejar, posso ajudar a criar um addon que:

    • Cria os objetos.
    • Cria scripts dentro do Text Editor.
    • Gera um guia/instruções automáticas para o usuário configurar os controllers.
    • Ou preparar um .blend template para duplicar e facilitar.

    Quer que siga assim?

  27. User

    Ou preparar um .blend template para duplicar e facilitar.

  28. Assistant

    Ótima escolha! Criar um arquivo .blend template com todos os objetos e lógica já configurada e fazer o addon simplesmente importar ou linkar esses objetos para a cena atual é a forma mais prática e confiável hoje, já que a API não permite criar logic bricks via script.


    Passos para fazer isso

    1. Preparar o arquivo .blend template

    • Abra o UPBGE/Blender e crie a cena base do seu jogo:
      • Personagem com lógica e sensores configurados.
      • Itens colecionáveis com lógica.
      • Câmera com lógica.
    • Salve como, por exemplo, game_template.blend.

    2. Criar o addon para importar/linkar o conteúdo do template

    O addon vai:

    • Adicionar um operador que importa/linka os objetos do .blend template na sua cena atual.

    Exemplo básico de addon para importar os objetos de um .blend

    Salve o template .blend num caminho fixo (exemplo: dentro da pasta do addon ou especificado no próprio addon).

    bl_info = {
        "name": "UPBGE Game Template Importer",
        "author": "Seu Nome",
        "version": (1, 0),
        "blender": (2, 80, 0),
        "location": "View3D > Sidebar > UPBGE Game",
        "description": "Importa um template pronto de jogo UPBGE com lógica configurada",
        "category": "Game Engine",
    }
    
    import bpy
    import os
    
    # Ajuste esse caminho para o local correto do seu arquivo template
    # Você pode usar um caminho absoluto ou relativo ao addon
    TEMPLATE_BLEND_PATH = os.path.join(os.path.dirname(__file__), "game_template.blend")
    
    def append_objects_from_blend(blend_path, object_names):
        # Aponta para a pasta Objects dentro do .blend
        with bpy.data.libraries.load(blend_path, link=False) as (data_from, data_to):
            objects_to_append = [name for name in object_names if name in data_from.objects]
            data_to.objects = objects_to_append
    
        for obj in data_to.objects:
            if obj is not None:
                bpy.context.collection.objects.link(obj)
    
    class UPBGEGAME_OT_import_template(bpy.types.Operator):
        bl_idname = "upbgegame.import_template"
        bl_label = "Importar template do jogo"
        bl_description = "Importa objetos do template pronto para UPBGE com lógica configurada"
    
        def execute(self, context):
            object_names = ["Player", "Collectible", "Collectible.001", "GameCamera"]  # Ajuste conforme seu template
            if not os.path.exists(TEMPLATE_BLEND_PATH):
                self.report({'ERROR'}, f"Arquivo template não encontrado:\n{TEMPLATE_BLEND_PATH}")
                return {'CANCELLED'}
    
            append_objects_from_blend(TEMPLATE_BLEND_PATH, object_names)
            self.report({'INFO'}, "Template do jogo importado com sucesso!")
            return {'FINISHED'}
    
    class UPBGEGAME_PT_panel(bpy.types.Panel):
        bl_label = "UPBGE Game"
        bl_idname = "UPBGEGAME_PT_panel"
        bl_space_type = 'VIEW_3D'
        bl_region_type = 'UI'
        bl_category = "UPBGE Game"
    
        def draw(self, context):
            layout = self.layout
            layout.operator("upbgegame.import_template", icon='IMPORT')
    
    classes = (UPBGEGAME_OT_import_template, UPBGEGAME_PT_panel)
    
    def register():
        for cls in classes:
            bpy.utils.register_class(cls)
    
    def unregister():
        for cls in reversed(classes):
            bpy.utils.unregister_class(cls)
    
    if __name__ == "__main__":
        register()
    

    Como usar

    1. Coloque seu arquivo game_template.blend na mesma pasta do addon .py ou ajuste a variável TEMPLATE_BLEND_PATH para o caminho correto.
    2. Instale e ative o addon no UPBGE ou Blender.
    3. No 3D View, abra a Sidebar (N) e vá até a aba UPBGE Game.
    4. Clique em Importar template do jogo para inserir os objetos com toda lógica pré-configurada na sua cena.
    5. Pressione P para rodar o jogo.

    Vantagens dessa abordagem

    • Nenhuma limitação da API para creación de logic bricks.
    • Template com lógica testada, funcionando e editável.
    • Processo automatizado para iniciantes e usuários avançados.
    • Facilita manutenção e expansão do jogo.

    Se quiser, posso ajudar a preparar um exemplo do arquivo .blend ou melhorar o addon para, por exemplo, copiar entre coleções, mover objetos importados, renomear para evitar conflitos, etc.

    Quer que eu prepare algo assim para você?

  29. User

    preparar um exemplo do arquivo .blend

  30. Assistant

    Claro! Posso te guiar para preparar um arquivo .blend simples, completo com objetos e lógica configurada para UPBGE, pronto para usar como template de importação. Vou te mostrar os passos para criar esse arquivo, as configurações que precisa e algumas dicas para organizar bem.


    Passo a Passo para Criar um Arquivo .blend Template para UPBGE


    1. Crie uma nova cena no UPBGE

    • Abra o UPBGE (versão compatível com seu addon).
    • Crie uma nova cena limpa.

    2. Adicionar e configurar o personagem (Player)

    • Adicione um cubo (Shift + A > Mesh > Cube).
    • Renomeie para Player no Outliner.
    • Ajuste a posição (Alt + G para limpar transformações e posicione em z=1).

    Configurar lógica:

    • Selecione o cubo Player.
    • Abra o logic editor (Logic Editor workspace).
    • Adicione um Sensor Always, habilite "True level triggering (pulse mode)".
    • Adicione um Controller Python.
      • Defina o tipo como Script.
      • No campo Script, selecione ou crie player_move.py (criar no Text Editor, veja abaixo).
    • Conecte sensor ao controller.

    Crie o script player_move.py:

    • Vá para o Text Editor, crie um novo texto chamado player_move.py.
    • Cole o código abaixo:
    import bge
    
    def main(cont):
        obj = cont.owner
        keyboard = bge.logic.keyboard
        speed = 0.1
        from bge import events
    
        if keyboard.events[bge.events.WKEY] == bge.logic.KX_INPUT_ACTIVE:
            obj.applyMovement([0, speed, 0], True)
        if keyboard.events[bge.events.SKEY] == bge.logic.KX_INPUT_ACTIVE:
            obj.applyMovement([0, -speed, 0], True)
        if keyboard.events[bge.events.AKEY] == bge.logic.KX_INPUT_ACTIVE:
            obj.applyMovement([-speed, 0, 0], True)
        if keyboard.events[bge.events.DKEY] == bge.logic.KX_INPUT_ACTIVE:
            obj.applyMovement([speed, 0, 0], True)
    

    3. Adicionar objeto coletável (Collectible)

    • Adicione uma ico sphere ou esfera (Shift + A > Mesh > Ico Sphere).
    • Renomeie para Collectible.
    • Ajuste posição (x=3, y=0, z=1).
    • No painel Game Properties (aba Lógica), configure as propriedades de colisão:
      • Collision bounds: enable e tipo Sphere.
    • No Logic Editor:
      • Adicione um sensor Collision:
        • Defina Property para Player (ou sem propriedade, conforme configuração desejada).
        • Ative pulse mode.
      • Adicione um Python controller com script collectible_logic.py.
      • Conecte sensor ao controller.

    Crie o script collectible_logic.py

    No Text Editor:

    import bge
    
    def main(cont):
        own = cont.owner
        collision_sensor = cont.sensors['Collision']
        if collision_sensor.positive:
            own.endObject()
            print("Item coletado!")
    

    4. Adicionar câmera com script de follow

    • Adicione uma câmera (Shift + A > Camera).
    • Posicione ela em (0, -10, 5).
    • Rotacione para olhar para a cena (X=1.2 rad).
    • No Logic Editor:
      • Adicione Sensor Always (pulse mode).
      • Adicione Controller Python para script camera_follow.py.
      • Conecte sensor a controller.

    Crie script camera_follow.py

    import bge
    
    def main(cont):
        cam = cont.owner
        scene = bge.logic.getCurrentScene()
        player = scene.objects.get("Player")
        if player:
            cam.position = player.position + [0, -10, 5]
            cam.lookAt(player)
    

    5. Ajuste os Grupos de Colisão

    • Se desejar, configure os grupos de colisão para Player e Coletável para evitar colisões erradas.
    • Isso é feito no painel Physics > Collision Groups (marque/desmarque grupos adequados).

    6. Salve o arquivo

    • Salve com um nome como game_template.blend.
    • Guarde onde seu addon possa acessá-lo, por exemplo na mesma pasta do .py do addon.

    Dicas finais

    • Teste rodar o jogo pressionando P dentro do UPBGE para garantir que tudo funciona.
    • Edite o blueprint e scripts se quiser adicionar mais lógica.
    • Se seu addon importar esses objetos, os nomes precisam coincidir (ex.: Player, Collectible, Collectible.001 etc).
    • Para adicionar mais objetos, siga o mesmo padrão.

    Se quiser, posso ajudar a montar um arquivo .blend exatamente com esses passos e te enviar o arquivo pronto, é só pedir!


    Quer que eu prepare e envie um arquivo .blend de exemplo para download?