Need some clarity on signals

[shayneoneill]

Hi, I'm trying to work out how the signals work in this, I cant really find it documented.

I'm trying to create a listener that sits on a root node , that can accept "towns" and "ids"

so something like register_town.= signal(id,town)

That of course doesn't work (For a start its unpythonic, whats an id , whats a town), but I cant really see any other way to specify those paramaters.

Secondly, even if I do just register_town = signal(), I never see that signal turn up in the inspector. Should it?

[adracea]

@shayneoneill hey , I've been toying around with using this project as well . What I've noticed :

1. You declare signals indeed like register_town = signal() . In order for them to pop up you have to restart the godot editor/reload project .
2. Currently , the only way I've found of "emitting signals" is using self.call("emit_signal","register_town")

I'm currently still struggling with finding a way to wait for signals or finding any documentation on doing it .( using the yield method that godot has)

[shayneoneill]

Ah ok. Thats troublesome. I'm now kind of wondering if I should perhaps just roll my own signal method. Though the usual call-back instant dispatch wouldn't work as its crossing too many barriers. Kinda feels like fighting against the system, which is never a good thing in programming.

[cr8ivecodesmith]

I'm currently still struggling with finding a way to wait for signals or finding any documentation on doing it .( using the yield method that godot has)

Were you able to figure out a way to do this? I'm currently trying out the "Your first game" tutorial and that uses the yield call of GDScript. I had to settle with boolean flags for now. What's a good workaround for this in the mean time?

[ghost]

This is literally the only documentation I can find on how one does signals in godot-python, but, how does one do signals that pass parameters? Do you just add arguments to the end of the self.call("emit_signal", "signal_name", ... )?

[omardelarosa]

This thread is unfortunately the only docs I have found. However, through some experimentation and looking at the source code for more information on how Signals are implemented, they definitely support argument passing and here's how it seems to work (at least as of my current godot version of 3.2.4beta):

# something.py

from godot import *

class Something(Node)
    # this variable name must match the string below
    player_move_success = signal()


   def player_has_moved_to(self, vec3_from_position, vec3_to_position):
        # After ensuring that both vec3 args are instances of Vector3() class...
        self.call("emit_signal", "player_move_success", vec3_from_position, vec3_to_position)

Then from the GDScript side:

extends Node

# Assuming there is a Something node as a child in the scene with the Python something.py attached to it.
onready var something_node = $Something

func _ready():
     # Observe the Python-based Something node's "player_move_success" signal
     something_node.connect("player_move_success", self, "_on_player_move_success")

func _on_player_move_success(from_position: Vector3, to_position: Vector3):
     print("player has successfully moved from ", from_position, " to ", to_position)

That being said keep in mind that the function signature's arity (i.e. the number of arguments) must match between the Python call and the observer. For example, these will not work and silently fail:

# Sending a mismatched function with only 1 argument
self.call("emit_signal", "player_move_success", vec3_from_position)

# Sending a mismatched function with no arguments
self.call("emit_signal", "player_move_success")

[MarioMey]

Anyone: this is still the best way to "emit signals"? Is this the best way to comunicate between code files? I used to use bge.logic.sendMessage(subject, body) a lot to comunicate between objects in Blender Game Engine. I think signals are the alternative in Godot, aren't they? Is there something better?

@adracea Did you find the way to wait for signals?

@cr8ivecodesmith Could you share the "Your first game" converted to Python? I'm doing the same right now, it is almost complete.

@shayneoneill Could you share your "own signal method"?

@cridenour Thanks for bring me here.

[MarioMey]

Well, after learning a bit about yield, I think I found an alternative in Python. Also with yield, but a bit more complicated. This is HUD.py, the GDScritp to Python converted code of "Your first game" (I only add comments where it is relevant to this thread):

from godot import exposed, export, signal, CanvasLayer
import time

@exposed
class HUD(CanvasLayer):
	start_game = signal()

	def _ready(self):
		self.connect("start_game", self.get_node("/root/Main"), "new_game")
		self.get_node("StartButton").connect("pressed", self, "_on_StartButton_pressed")
		self.get_node("MessageTimer").connect("timeout", self, "_on_MessageTimer_timeout")

	def show_message(self, text):
		self.get_node("Message").text = text
		self.get_node("Message").show()
		self.get_node("MessageTimer").start()

	# New function name
	def show_game_over_yield(self):
		self.show_message("Game Over")
                # Needed for the generator creation
		while True:
			# Wait for 'MessageTimer_timeout' message
			if (yield) == 'MessageTimer_timeout':
				self.get_node("Message").text = "Dodge the\nCreeps!"
				self.get_node("Message").show()
				time.sleep(1)
				self.get_node("StartButton").show()
				# We need to delete this generator now
				del self.sgo

        # This is the main function that is executed by Main.py
	def show_game_over(self):
                # Create the yield generator and run it till the yield line.
		self.sgo = self.show_game_over_yield()
		next(self.sgo)
		
	def update_score(self, score):
		self.get_node("ScoreLabel").text = str(score)

	def _on_StartButton_pressed(self):
		self.get_node("StartButton").hide()
		self.call("emit_signal", "start_game")

	def _on_MessageTimer_timeout(self):
		self.get_node("Message").hide()
                # Check if the generator is created and send message to it
		if hasattr(self, 'sgo'):
			self.sgo.send('MessageTimer_timeout')

[MarioMey]

Here are the other codes. I added lines to connect signals by code, instead of doing at hand. I always tried to do it in this way, when working with Blender Game Engine.

Main.py

from godot import exposed, export, signal, Vector2, Node, PackedScene, ResourceLoader
import random, math

@exposed
class Main(Node):

	mob_scene = ResourceLoader.load("res://Mob.tscn")
	score = int()

	def _ready(self):
		self.get_node("MobTimer").connect("timeout", self, "_on_MobTimer_timeout")
		self.get_node("ScoreTimer").connect("timeout", self, "_on_ScoreTimer_timeout")
		self.get_node("StartTimer").connect("timeout", self, "_on_StartTimer_timeout")
		pass
		
	def game_over(self):
		self.get_node("ScoreTimer").stop()
		self.get_node("MobTimer").stop()
		self.get_node("HUD").show_game_over()
		self.get_node("Music").stop()
		self.get_node("DeathSound").play()

	def new_game(self, mensaje=None):
		print(mensaje)
		self.score = 0
		self.get_node("Player").start(self.get_node("StartPosition").position)
		self.get_node("StartTimer").start()
		self.get_node("HUD").update_score(self.score)
		self.get_node("HUD").show_message("Get Ready")
		self.get_tree().call_group("mobs", "queue_free")
		self.get_node("Music").play()

	def _on_ScoreTimer_timeout(self):
		self.score += 1
		self.get_node("HUD").update_score(self.score)

	def _on_StartTimer_timeout(self):
		self.get_node("MobTimer").start()
		self.get_node("ScoreTimer").start()

	def _on_MobTimer_timeout(self):
		mob = self.mob_scene.instance()

		mob_spawn_location = self.get_node("MobPath/MobSpawnLocation")
		mob_spawn_location.offset = random.randrange(pow(2,32))

		direction = mob_spawn_location.rotation + math.pi / 2

		mob.position = mob_spawn_location.position

		direction += random.uniform(-math.pi / 4, math.pi / 4)
		mob.rotation = direction

		velocity = Vector2(random.uniform(150.0, 250.0), 0.0)
		mob.linear_velocity = velocity.rotated(direction)

		self.add_child(mob)

Player.py

from godot import exposed, export, signal, Vector2, Area2D, InputEventKey
from godot import KEY_RIGHT, KEY_LEFT, KEY_UP, KEY_DOWN

@exposed
class Player(Area2D):

	hit = signal()

	speed = export(int, default=400)
	screen_size = int()
	velocity = Vector2.ZERO
	velocity_real = Vector2.ZERO
	
	def _ready(self):
		self.connect("hit", self.get_node("/root/Main"), "game_over")
		self.connect("body_entered", self, "_on_Player_body_entered")
		screen_size = self.get_viewport_rect().size
		self.hide()

	def _unhandled_input(self, event):
		if type(event) is InputEventKey:
			if event.pressed and event.scancode == KEY_RIGHT and not event.echo:
				self.velocity.x += 1
			if event.pressed and event.scancode == KEY_LEFT and not event.echo:
				self.velocity.x -= 1
			if not event.pressed and event.scancode in [KEY_RIGHT, KEY_LEFT]:
				self.velocity.x = 0
			
			if event.pressed and event.scancode == KEY_DOWN and not event.echo:
				self.velocity.y += 1
			if event.pressed and event.scancode == KEY_UP and not event.echo:
				self.velocity.y -= 1
			if not event.pressed and event.scancode in [KEY_UP, KEY_DOWN]:
				self.velocity.y = 0
			
			if self.velocity.length() > 0:
				self.velocity_real = self.velocity.normalized() * self.speed
				self.get_node("AnimatedSprite").play()
			else:
				self.velocity_real = self.velocity
				self.get_node("AnimatedSprite").stop()
		
	def _process(self, delta):

		self.position += self.velocity_real * delta
		self.screen_size = self.get_viewport_rect().size
		self.position.x = max(0, min(self.position.x, self.screen_size.x))
		self.position.y = max(0, min(self.position.y, self.screen_size.y))

		if self.velocity.x != 0:
			self.get_node("AnimatedSprite").animation = "walk"
			self.get_node("AnimatedSprite").flip_v = False
			self.get_node("AnimatedSprite").flip_h = self.velocity.x < 0
		
		elif self.velocity.y != 0:
			self.get_node("AnimatedSprite").animation = "up"
			self.get_node("AnimatedSprite").flip_v = self.velocity.y > 0

	def _on_Player_body_entered(self, _body):
		self.hide()
		self.call("emit_signal", "hit")
		self.get_node("CollisionShape2D").set_deferred("disabled", True)
		
	def start(self, pos):
		self.position = pos
		self.show()
		self.get_node("CollisionShape2D").disabled = False

Mob.py

from godot import exposed, RigidBody2D
import random

@exposed
class Mob(RigidBody2D):

	def _ready(self):
		self.get_node("VisibilityNotifier2D").connect("screen_exited", self, "_on_VisibilityNotifier2D_screen_exited")
		self.get_node("AnimatedSprite").playing = True
		mob_types = self.get_node("AnimatedSprite").frames.get_animation_names()
		anim = mob_types[random.randint(0, len(mob_types) - 1)]
		self.get_node("AnimatedSprite").animation = anim

	def _on_VisibilityNotifier2D_screen_exited(self):
		self.queue_free()