getting_started/first_3d_game/08.score_and_replay

[giscus[bot]]

getting_started/first_3d_game/08.score_and_replay

In this part, we'll add the score, music playback, and the ability to restart the game. We have to keep track of the current score in a variable and display it on screen using a minimal interface. ...

https://docs.godotengine.org/en/stable/getting_started/first_3d_game/08.score_and_replay.html

[LuigiKraken]

In Godot 4.3 the Autoload Tab was replaced by the Global Tab. So when registering the autoload in the Project Settings the path is: Project -> Project Settings -> Global -> Autoload

[Catley94]

Thank you!

[Wadahell]

Everything worked, but i want to know how do I make a scoreboard with the highest scores if anybody knows
(thanks in advance 'v')

[lucianoinso]

There are a lot of ways to do this, I'll give you a general idea on how I'd implement this:

You absolutely need a file to save and retrieve the scores, so maybe dig into how godot handle files.
Then, let's say you want a "top 10", one way to use the file could be having 10 lines, each one with a score. Another way is to have just one line, and separate the scores with a comma, then when you read the file you just read the first line, use split(",") and save it into a high_scores variable which is a list/array, this variable could live in the Main script.
You want the scores in descending order so use sort() and reverse(), you can also have the score in another UI node like what's done in this tutorial.

Let's say you save the high scores inside a variable in the Main scene, then, when the player dies and sends the player_hit() signal you could check in _on_player_hit() function inside Main if the current score is greater or equal than the minimum score in the scoreboard, you could use something like if score > high_scores[-1]: ..., or you could also always add the score to the list, sort it, and slice it at 10, and then you'll need to save the scores back into the high scores file so that they remain persistent, the code would be something similar to this:

var high_scores

func _ready():
    # Called every time the node is added to the scene.
    # Initialization here
    high_scores = load_scores("PathToYourFile") # You need to create the function load_scores()

func _on_player_hit() -> void:
    # ... 
    high_scores.append(score)  # You'll need to retrieve the score from main too, now it's on a Label
    high_scores.sort()
    high_scores.reverse() # So it is in descending order, from maximum to minimum
    high_scores = high_scores.slice(0, 10) # We chop it at the 10 highest ones
	save_scores(high_scores) # Then save the new high scores into file

Then add another button similar to "Retry", with the label "Highest scores" or something like that, which shows you another scene with some UI nodes with the top 10 scores.

That's the rough idea and part of the code you could use, hope it inspires you to do it yourself.

Hope it helps! : )

[Menekrr]

I found that the ui_accept event is also triggered by pressing <Spacebar>. I double-checked Project -> Project Settings -> Input Map and ensured that there was no ui_accept action already defined. I wanted to restrict the "Retry" after game over to only the <Enter> key.

The way I solved this was:

• Create a new action in Input Map called retry_accept, add the <Enter> key to it.
• In the Main scene script main.gd, modify the _unhandled_input(event: InputEvent) function's if statement to the following:
  if event.is_action_pressed("retry_accept") and $UserInterface/Retry.visible:

And now, when my player is killed, the game can only be restarted with the <Enter> key. <Space> no longer has an effect.

[de-nickm]

You do have a ui_accept action already defined, but you have to toggle Show Built-in Actions from the Input Map page in order to see it. Once that's toggled, you'll see the built-in ui_accept action and you can remove the mapping to <Spacebar> if desired.

[simplesi83]

Thank you both, I tried both ways, it helped me understand what was going on. Have mine set to only now but also add a controller button to restart the game via the ui_accept

[RensTillmann]

Since I tried to play around and do it my own way a little bit (as it allows me to learn things better) I came up with this way (see code below).

The cool thing I learned is: you can get a reference of any node from anywhere in your scripts just like you would with require_once('../path/to/file.php') in PHP or other languages while trying to include other scripts. You just need to make sure you go up a directory depending on where the child node is located based of the Main node (I guess) just like you would in other languages. So I guess in some way you could think about "Nodes" as "Files/Dirs"????.

For instance, if you are in the player.gd and you would want to get the ScoreLabel node (which is located inside Main/UserInterface in this tutorial, you could call get_node("../UserInterface/ScoreLabel").

Now let's asume you want to call a function that is located in your main.gd, but from inside your player.gd script. In this case both of these methods will work:

1. get_node("../../Main").update_score(1)
2. get_node("/root/Main").update_score(1).

The first method being the relative path method so it depends where (read: how deep) your Node is located in the list.

I think this makes everything a lot easier while coding. It means as long as you know the names of the Nodes that you have, you can always get a reference to them? Just not sure how this would work if you have multiple instances of them (like with the mobs in this example, I guess you can loop over them or something haha).

main.gd:

var score = 0
func update_score(amount): # 1 = increase by 1, 0 = game over
	if amount == 0:
		score = 0
		game_over()
	else:
		score += amount
	update_ui()

func update_ui():
	var n = get_node("UserInterface/ScoreLabel")
	n.text = "Score: %d" % score

func game_over():
	# show restart game button
	pass

player.gd

		# If the collider is with a mob
		if collision.get_collider().is_in_group("mob"):
			var mob = collision.get_collider()
			var normal = collision.get_normal()
			# we check that we are hitting it from above.
			if Vector3.UP.dot(normal) > 0.1:
				print("Squash it!")
				# If so, we squash it and bounce.
				mob.squash()
				target_velocity.y = bounce_impulse
				# Prevent further duplicate calls.
				# Update score
				get_node("/root/Main").update_score(1) # e.g. higher numbers for more difficult enemies
				break
			else:
				# Check if hitting from the sides, front, or back
				#if normal.dot(Vector3.UP) <= 0.1: # This ensures it's not hitting from above
				# Handle collision from front, back, or sides
				print("Hit from the side, front, or back!")
				# Game over logic here...
				get_node("/root/Main").update_score(0) # when passing 0 it means game over
				break

[RensTillmann]

Regarding the "Autoload" method for our music, does it mean it only loads it one single time and not multiple times since the game is executing the main.tscn even though the main.tcsn contains multiple other scenes?

[RensTillmann]

In the Remote tab while playing the game, I also see the MusicPlayer only one time, so I guess it won't affect how many scenes you have in total (which makes sense). The following sentense was confusing to me a little bit (especially the now loads into any scene).

"music_player.tscn now loads into any scene you open or play. So if you run the game now, the music will play automatically in any scene."

[Anhilliator1]

The score refuses to update for me for reasons unknown. I'm not sure if the label is recieving the signal or not. I am using C#, and as far as I can tell, my code is identical to that provided here.

[RostagRed]

Probably quite late, but for these type of tutorial:s if you are 100% certain the code is identical then it is probably something to do with the nodes. Whether that is a hierarchy issue, an option not checked in the inspector or a node not positioned correctly you will have to debug for.

[chihwahli]

just check, at both sides: print statement at the place where you emit() the signal, then you know if it is send. 2nd print statement at the receiver side, that connected to the signal, place the 2nd print statement there. if not work, disconnect and retype the signals.

[abrossimow]

I wonder about the mob.squashed.connect implementation here. It seems not that flexible. What would other possible implementations look like? It certainly is good for demonstrating how to bind signals from code, though :)

Alternatively we could update scores through the player by signaling to score after mob.squash?
Or connect the squashed signal to another object acting like an interface?
How would I implement an interface logic for example?

I'd love to hear more ideas.

[chihwahli]

yes, you can. Godat allows you to create custom signals. Just type signal followed by your own signal name, it will be show in the list of possible signals, then you can let any script connect to it as you like.

in player I typed at the top: signal increase_point
Then just under the method call "mod.squash() function, I send the signal with: increase_point.emit()
Then click the script you want to receive the signal, and click the node that sends the signal. Double click that signal to connect.

so, click for instance the script of the score, then click player node, in the right in the inspector, click "node" to see all the signals being send. Double click the signal you want to connect to. and the method will be pasted into the score script. Type any code or other function into it, to execute it.

This means, you can send a signal from any script, to any script(s)

In bigger games you use a certain pattern to solve this, because there will be hundreds of signals going around continuously.
Have search on game patterns.

[robbyph]

What is the purpose of the .bind() function at the end of the line where you connect the signal to the score?

mob.squashed.connect($UserInterface/ScoreLabel._on_mob_squashed.bind())

According what I've seen in the docs, bind doesen't really do anything without an argument, so not sure what it does here