Perguntas[godot](coding)

Estou tentando fazer o fim de uma linha no cursor. Mas não funciona.

Com janela:

Tela cheia:

Como você pode ver, a linha azul não termina no cursor.

Aqui está meu código para isso:

extends Line2D

# Called when the node enters the scene tree for the first time.
func _ready() -> void:
    #gets parent's position
    var parent := get_parent()
    
    #sets 2 points for the line
    add_point(parent.position)
    add_point(parent.position)



# Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(delta: float) -> void:
    #deletes last position (cursor position)
    remove_point(1)
    
    #calculates the new point position
    var mousePos := get_global_mouse_position() #gets mouse position
    var adjust   := get_viewport_rect().size    #gets screen
    var deltaPos  = mousePos - (adjust/2)       #Adjust the coordinate (Point's (0,0) is in the middle of the screen while cursor's is on the top left corner)
    add_point(Vector2(deltaPos))
    print(deltaPos, points[1])

A linha é uma criança de uma Área 2d Assim (que tem um sprite 2d como filho correspondente ao edifício em um quadrado. Aqui está toda a construção

Cada vez que a função '_process' é chamada, eu imprimo as coordenadas do mousse e as coordenadas do ponto final que devem estar no cursor. Você pode ver na imagem da janela que essas coordenadas são as mesmas

No começo a diferença era bem mais visível. Antes:

Isso ocorreu porque as coordenadas do mouse e do ponto não têm a mesma origem (canto superior esquerdo para o primeiro e centro da tela para o segundo).

Sou novo no Stack Overflow e no Game Development, então desculpe se essa pergunta for estúpida. Atualmente, estou trabalhando em um jogo no godot onde um jogador pode atirar projéteis em inimigos (simplificação excessiva). No entanto, tenho o seguinte problema: o projétil surge dentro do modelo do jogador e então colide com o jogador que o atira e ricocheteia. Meu projétil usa o tipo RigidBody2D e o Player é um CharacterBody2D.

Eu tentei o seguinte:

Defina a máscara da camada de colisão para estar em uma camada diferente do player

Problema: O projétil deve ricochetear nas paredes e então deve ser capaz de atingir o jogador. Então, os dois precisam ter colisão.

Faça a primeira sugestão, mas habilite a camada de máscara após o primeiro salto de parede

Problema: Mais tarde, quero usar algo semelhante a mísseis guiados. O jogador pode atirar mísseis que seguem o mouse e então atingem os inimigos ou o jogador. Então, o projétil deve ser capaz de colidir com o jogador sem um salto na parede.

Faça a primeira sugestão, mas habilite a camada de máscara após x quantidade de milissegundos

Problema: Os projéteis têm velocidades diferentes e o jogador pode ter modelos de tamanhos diferentes, então eu gostaria de evitar algo assim.

Gere o projétil com um deslocamento para que ele comece fora da área de impacto do jogador

Problema: Eu tentei isso e não pareceu, especialmente com modelos de jogadores variados. Mas se não houver outra solução, essa provavelmente seria a melhor opção.

Basicamente, eu gostaria de desabilitar a colisão entre os dois, então ter o sinal body_exited disparado quando o projétil sai da hitbox do jogador e então reativar a colisão. O problema é que se eu desabilitar a colisão, o sinal body_exited não dispara porque não há colisão. Mas com a colisão habilitada, o projétil ricocheteia no jogador. Basicamente, o que eu quero é que não haja interação física entre os dois inicialmente, mas com detecção de colisão ativa. Qualquer ajuda seria apreciada. Além disso, como sou novo, conselhos de melhores práticas são muito apreciados. Se o que estou fazendo é considerado uma prática ruim, por favor me avise.

Estou enfrentando um erro ao awaitser acionado várias vezes dentro de um loop.

O que o código deve fazer é um loop por todos os impérios, dizendo a eles para fazerem seus turnos e então awaiting sua conclusão antes de acionar o próximo império. Isso funciona para o primeiro turno (o turno do jogador), mas quando uma IA tenta chamar endTurn(), eu recebo o erro:

E 0:01:08:0911   Map.gd:419 @ endTurn(): Resumed function 'beginRound()' after await, but script is gone.  
    At script: res://scripts/HostGameMenu.gd:197  
    <C++ Error>    Method/function failed. Returning: Variant()  
    <C++ Source>   modules/gdscript/gdscript_function.cpp:197 @ resume()  
    <Stack Trace>  Map.gd:419 @ endTurn()  
    Tribe.gd:221 @ takeTurn()  
    Map.gd:414 @ beginNewTurn()  
    HostGameMenu.gd:196 @ beginRound()  
    Map.gd:419 @ endTurn()  
    Map.gd:1912 @ endEmpireTurn()  

Funções do Script One:

func beginRound():
    for i in range(empireTurnOrder.size()):
        empireTurnIndex = i #the only purpose this serves is being able to easily access whose turn it is for debugging from outside the for loop
        gameMap.beginNewTurn.rpc(empireTurnOrder[empireTurnIndex]) #empireTurnOrder is a PackedStringArray
        await gameMap.beginNextTurn
    gameMap.endRound.rpc() #gameMap points to the node containing Script Two

Script Duas Funções:

signal beginNextTurn

@rpc("any_peer", "call_local", "reliable")
func beginNewTurn(nextEmpire: String) -> void:
    var empire = getEmpire(nextEmpire)
    if empire.playerId != -1 and empire.playerId != userEmpire.playerId: #check is only for multiplayer, which is not the case for my tests. userEmpire is a reference to the empire node (node of Script Three) that the player controls
        pass
    else:
        if empire.playerId == userEmpire.playerId:
            #UI edits, irrelevant
        empire.takeTurn() #empire points to the node(s) of Script Three

func endTurn():
    if not serverHandler.inServer or multiplayer.get_unique_id() == 1: #serverHandler points to the node of Script One. inServer will always be true for singleplayer, which I am testing
        print(is_instance_valid(serverHandler))
        emit_signal("beginNextTurn")

func endRound():
    if not serverHandler.inServer or multiplayer.get_unique_id() == 1:
        serverHandler.beginRound()

func endEmpireTurn(): #button is tied to this function
    #edits UI a little
    endTurn()

Script Três Funções:

func takeTurn():
    if playerId == -1:
        map.endTurn() #map points the node of Script Two
    else:
        #does nothing; button press will call endTurn for players

Saída impressa:

Verdadeiro Verdadeiro

Qualquer ajuda é bem-vinda. As únicas outras postagens que encontrei sobre esse erro eram de pessoas aguardando timers em _process()funções, e as respostas para essas perguntas não eram exatamente aplicáveis ​​à minha situação.

Editar:

Adicionei uma função ao Script One:

func turnEnded() -> void:
    print(empireTurnOrder[empireTurnIndex] + "'s turn is over.")

e conectou o beginNextTurnsinal a ele, e também imprimiu com sucesso/corretamente para ambas as emissões do sinal, mas o erro não mudou.

Edição 2:

Só por curiosidade para ver se funcionava, alterei duas funções, beginNewTurn e beginRound, assim:

@rpc("any_peer", "call_local", "reliable")
func beginNewTurn(nextEmpire: String) -> bool:
    var empire = getEmpire(nextEmpire)
    if empire.playerId != -1 and empire.playerId != userEmpire.playerId:
        pass
    else:
        if empire.playerId == userEmpire.playerId:
            loadedData.get_node("ImportantMenuHub/EndTurn").set_disabled(false)
            loadedData.get_node("ResourceHUD/RaiseAll").set_disabled(false)
        empire.takeTurn()
    await beginNextTurn
    return true

func beginRound():
    for i in range(empireTurnOrder.size()):
        empireTurnIndex = i
        await gameMap.beginNewTurn(empireTurnOrder[empireTurnIndex])
    gameMap.endRound.rpc()

E isso dá o erro "O parâmetro "função" é nulo" na emit_signal("beginNextTurn")linha. Agora, obviamente, eu quero que minha solução seja compatível com chamadas de função rpc, mas é muito estranho que o sinal se recuse a funcionar corretamente com beginRound()and beginNewTurn(). A saída para isso, a propósito, ainda é

A vez de
<império 1> acabou. A vez
de
<império 2> acabou.

Tenho um tanque na cena com uma torre anexada como um objeto filho. Também tenho uma câmera na cena que gira usando um script, preciso que a torre do tanque gire suavemente conforme a câmera gira.

Alguém tem alguma ideia de como girar suavemente a torre depois da câmera, para que quando o tanque girar, a torre permaneça no lugar (porque a câmera não gira)

Implementei algo semelhante, mas quando o tanque gira, a torre gira junto, mas como a câmera não gira neste momento, agora há espaço livre entre a rotação da câmera e da torre.

Árvore de cena do tanque: https://i.imgur.com/BgwBz0q.png (para fazer o nó da câmera independente do objeto pai, eu uso este código no script do nó da câmera)

func _ready():
Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)
set_as_top_level(true)

Rotação que preciso: https://youtu.be/23IdDtPB4t0

(eu fiz um post parecido com esse, só que decidi mudar para o godot para poder tornar os jogos mais fáceis do que no flash, já que ele está desatualizado)

Eu criei um personagem que o jogador pode controlar e ele se move por meio de tiles e tilemap, eu quero fazer com que o jogador possa se mover para sempre quando uma tecla de seta for pressionada (e se mover na direção da tecla de seta) até que ele entre em um tile caminhável que esteja tocando em um tile não caminhável

você pode me dar alguma dica de como fazer isso, aqui está o código:

extends Sprite2D

class_name PacMan

@export var move_speed: float = 1



@onready var tile_map: TileMap = $"../TileMap"

@onready var sprite_2d: Sprite2D = $Sprite2D

@onready var animation_player: AnimationPlayer = $Sprite2D/AnimationPlayer


var is_moving = false

func _physics_process(delta: float) -> void:
    if is_moving == false:
        return
    if global_position == sprite_2d.global_position:
        is_moving = false
        return
    sprite_2d.global_position = sprite_2d.global_position.move_toward(global_position, move_speed)

func _ready() -> void:
    animation_player.play("chomping")

func _process(delta: float) -> void:
    if is_moving:
        return
    if Input.is_action_pressed("up"):
        rotation_degrees = 90
        move(Vector2.UP)
        is_moving = true
    elif Input.is_action_pressed("down"):
        rotation_degrees = 270
        move(Vector2.DOWN)
        is_moving = true
    elif Input.is_action_pressed("left"):
        rotation_degrees = 0
        move(Vector2.LEFT)
        is_moving = true
    elif Input.is_action_pressed("right"):
        rotation_degrees = 180
        move(Vector2.RIGHT)
        is_moving = true

func move(direction: Vector2):
    var current_tile: Vector2i = tile_map.local_to_map(global_position)
    var target_tile: Vector2i = Vector2i(
        current_tile.x + direction.x,
        current_tile.y + direction.y,
    )
    var tile_data: TileData = tile_map.get_cell_tile_data(0, target_tile)
    if tile_data.get_custom_data("walk_tiles") == false:
        return
    #Player movement
    is_moving = true
    global_position = tile_map.map_to_local(target_tile)
    sprite_2d.global_position = tile_map.map_to_local(current_tile)

Ao iniciar o jogo, recebo este erro. Existe alguma maneira de resolver o problema?

extends Node2D

var coin = preload("res://coin.gd")

func _on_timer_timeout():
    var coinTemp = coin.instantiate()   
    var generator = RandomNumberGenerator.new()
    var genint = randi_range(50, 500)
    coinTemp.position = Vector2 (genint,560) 
    add_child(coinTemp)

Não consegui encontrar nenhuma informação sobre como resolver este problema

Estou tentando imitar uma transformação 3D em um ambiente 2D e, portanto, estou tentando fazer sozinho a parte 3D dos cálculos

Para referência, usei um Node3D para verificar se meu método de cálculo está correto

func calc_transform_3d(position_3d:Vector3, rotation_3d:Vector3, scale_3d:Vector3 ) -> Transform3D:
    
    var transform_3d := Transform3D(
        Basis.from_euler(rotation_3d).scaled(scale_3d),
        position_3d
    )
    
    return transform_3d

func _ready():
    var node_3d:Node3D = $Node3D
    var custom_transform := calc_transform_3d(node_3d.position, node_3d.rotation, node_3d.scale)
    
    print(custom_transform == node_3d.transform) # returns false

Mas o calc_transform_3d()método fornece a saída errada (para sua informação, não é um erro de ponto flutuante que verifiquei)

Então , como calcular um Transform3D (semelhante a como um Node3D o calcula) dado apenas positione ?rotationscale

Sou iniciante em Godot, atualmente estou brincando com armas hitscan etc., e usandointersect_ray()

Ao tentar escrever código usando, Intersect_ray()continuo recebendo uma mensagem de erro "Muitos argumentos para a chamada "intersect_ray ()". Esperado no máximo 1, mas recebeu 2." não sei o que fiz de errado? Aqui está o código: var collision = bullet.intersect_ray(muzle.transform.origin, aimcast.get_collision_point

se ajudar, estou usando um tutorial: https://www.youtube.com/watch?v=4jbfIN4t83k&list=PLJJ-tyPiN1L_68DjYLfn7c1Yq8Kx6NWPw&index=7

Eu tenho código de caracteres:

extends CharacterBody3D
@onready var camera_mount = $camera_mount
@onready var animation_player = $visuals/mixamo_base/AnimationPlayer
@onready var visuals = $visuals
@onready var camera_3d = $camera_mount/Camera3D

@export var is_current:bool = true
@export var is_main = true
@export var SPEED = 5.0
@export var JUMP_VELOCITY = 4.5
@export var SENSIVITY = 0.05
var walk_speed = 3.0
var run_speed = 5.0
var is_running = false
var gravity = ProjectSettings.get_setting("physics/3d/default_gravity")

func _ready() -> void:
    if is_main:
        Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)

func _input(event):
    if is_main:
        if event is InputEventMouseMotion:
            rotate_y(deg_to_rad(-event.relative.x*SENSIVITY))
            visuals.rotate_y(deg_to_rad(event.relative.x*SENSIVITY))
            camera_mount.rotate_x(deg_to_rad(-event.relative.y*SENSIVITY))
            

        
func _physics_process(delta):
    if is_main:
        camera_3d.current = is_current

        if not is_on_floor():
            velocity.y -= gravity * delta
        if Input.is_action_pressed("run"):
            SPEED = run_speed
            is_running = true
        else:
            is_running = false
            SPEED = walk_speed
            

        if Input.is_action_just_pressed("ui_accept") and is_on_floor():
            velocity.y = JUMP_VELOCITY
            
        if Input.is_action_just_pressed("ui_cancel"):
            Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)


        var input_dir = Input.get_vector("move_left", "move_right", "move_forward", "move_back")
        
        var direction = (transform.basis * Vector3(input_dir.x, 0, input_dir.y)).normalized()
        if direction:
            if animation_player.current_animation != "walking" && is_running == false:
                animation_player.play("walking")
                
            if animation_player.current_animation != "running" && is_running:
                animation_player.play("running")
            
                
            visuals.look_at(position+direction)
                
            velocity.x = direction.x * SPEED
            velocity.z = direction.z * SPEED
        else:
            if animation_player.current_animation != "idle":
                animation_player.play("idle")
                
            velocity.x = move_toward(velocity.x, 0, SPEED)
            velocity.z = move_toward(velocity.z, 0, SPEED)
            
        camera_mount.rotation.x = clamp(camera_mount.rotation.x, 
            deg_to_rad(-90), 
            deg_to_rad(70)
        )

        move_and_slide()

E o script responsável por mudar o personagem do jogo através de um botão:

extends Node3D

@onready var player_1 = $"../Player1"
@onready var player_2 = $"../Player2"

func _physics_process(_delta):
    if Input.is_action_just_pressed("switch_player"):
        if player_1.is_main:
            player_1.is_main = false
            player_2.is_main = true
            player_2.is_current = true
            player_1.animation_player.play("idle")
        else:
            player_1.is_main = true
            player_2.is_main = false
            player_1.is_current = true
            player_2.animation_player.play("idle")

O problema é que se você mudar de jogador enquanto aquele para quem você estava jogando antes está no ar, ele congela nesta posição. Como posso fazer com que, assim que troco de jogador, aquele em que joguei antes caia no chão, ou seja, comece a sucumbir às leis da física?

Sim, a bola está entrando (e saindo) da área2D quando inicio o jogo

Sim global.gd, é um script carregado automaticamente

No global eu tenho uma grande área2d que detecta se um corpo entrou. var chase_balldentro do global estão sendo atualizados mas no Global.chase_ballé sempre falso (o valor padrão)

Originalmente o area2D estava dentro do nó inimigo mas eu quero que o area2D seja fixado na cena principal, não se movendo junto com o inimigo

global.gd:

extends Node2D

var chase_ball = false

func _process(delta):
        print(chase_ball)

func _on_ball_detector_body_entered(body):
    chase_ball = true

func _on_ball_detector_body_exited(body):
    chase_ball = false

saída:

true
false
true
false
(same loop as above)

inimigo.gd:

func _process(delta):
    print(Global.chase_ball)

saída:

false
false
false
false
(same loop as above)

O resultado esperado é Global.chase_ballatualizar de acordo com ofunc _on_ball_detector_body_entered/exited(body):