d20 system mechanics in Godot - godot

Question

I'm having trouble with the code below. The attacker is doing two rounds before reversing the turn, and the correct thing is to have a round of attack and alternate. Another detail is that the 'for' doesn't seem to be working... it gets information on how much dice the player has, but for some reason, the 'print' I put doesn't return 2 values (for example, for a player with two dice). I believe there is a lot to improve, creating more functions, but I am a beginner.
AutoLoad:
extends Node2D
var enemy_turn : bool = false
var critical_Hit : bool = false
func _start_combat(player, enemy):
if enemy_turn == false:
turn(enemy, player)
else:
turn(player, enemy)
func roll(dice) -> int:
var random_number = RandomNumberGenerator.new()
random_number.randomize()
return random_number.randi_range(1, dice)
func turn(target, attacker):
print(attacker.char_name, " attack ", target.char_name)
var iniciative_roll = roll(20)
print("Iniciative d20: ", iniciative_roll)
if iniciative_roll == 20:
print("Critical Hit!") #Tenho que verificar se eu estou saindo daqui sem passar para baixo visto que 20 >= abs()
critical_Hit = true
elif iniciative_roll >= abs(target.ac - attacker.thac0):
critical_Hit = false
else:
print(attacker.char_name, " miss.")
enemy_turn =! enemy_turn
_start_combat(attacker,target)
return
var dmg_roll : int = 0
for n in attacker.row:
dmg_roll += roll(attacker.dice)
print(dmg_roll)
return damage(target, attacker, dmg_roll)
func damage(target, attacker, aux):
if critical_Hit == true:
target.hp -= 2 * aux
else:
target.hp -= aux
print(attacker.char_name, " do ", aux, " damage ", target.char_name)
if target.hp <= 0:
target._death()
else:
enemy_turn =! enemy_turn
_start_combat(attacker,target)
Taking advantage, can the arguments that a function receives be the same as the variables sent? Is this not very ugly or wrong? Ex:
func turn(target, attacker):
...
return damage(target, attacker, dmg_roll)
func damage(target, attacker, dmg_roll):
...
Thanks

Answer 1

The attacker is doing two rounds before reversing the turn, and the correct thing is to have a round of attack and alternate.
Have another look at this code:
func _start_combat(player, enemy):
if enemy_turn == false:
turn(enemy, player)
else:
turn(player, enemy)
It will flip the order of the arguments of turn depending on enemy_turn.
The parameters of turn are like this:
func turn(target, attacker):
And then they do this:
enemy_turn =! enemy_turn
_start_combat(attacker,target)
Remember that enemy_turn controls if _start_combat flips the arguments or not. But also notice you are calling _start_combat with the arguments flipped. So there is always a flip, but depending on enemy_turn there is an extra flip… And the flips cancels out resulting in a repeated turn.
There is an extra wrinkle in that damage does the same thing that turn does:
enemy_turn =! enemy_turn
_start_combat(attacker,target)
This is the logic we need to change, and preferably we want to change it in a single place. A single source of truth of how to change turns.
You should refactor repetition out of damage. Furthermore…
I believe you want to have turn not be concerned with the order. Otherwise you would have put the logic you have in _start_combat inside of turn. Thus, don't have turn be concerned with the order at all! It should not be manipulating enemy_turn =! enemy_turn. In fact, it should not be calling _start_combat.
So we are separating these two concerns:
How to switch turns
How to execute turns
To do that we would put the logic of switching turn in _start_combat. It can have a loop where it calls turn one way, and then the other. Ah, but that reveals that we need to extract the end of combat logic.
Currently you are not having an stack overflow because combat is short enough. But your stack will be calls to _start_combat that call turn that call _start_combat that call turn that call _start_combat and so on.
Currently the end of combat logic is in damamge:
if target.hp <= 0:
target._death()
It ends combat by not calling _start_combat again.
So you can do something like this:
func _start_combat(player, enemy):
var target
var attacker
while true:
if enemy_turn == false:
target = enemy
attacker = player
else:
target = player
attacker = enemy
turn(target, attacker)
if target.hp <= 0:
target._death()
break
EDIT: In the above code I forgot to change enemy_turn. It should be in the loop:
func _start_combat(player, enemy):
var target
var attacker
while true:
if enemy_turn == false:
target = enemy
attacker = player
else:
target = player
attacker = enemy
turn(target, attacker)
if target.hp <= 0:
target._death()
break
enemy_turn =! enemy_turn
Then damage can be just this:
func damage(target, attacker, aux):
if critical_Hit == true:
target.hp -= 2 * aux
else:
target.hp -= aux
print(attacker.char_name, " do ", aux, " damage ", target.char_name)
And remove these from turn too:
enemy_turn =! enemy_turn
_start_combat(attacker,target)
I can tell you right now that the above code likely won't stand in the long run. Presumably you want to add animations, sound effects, or similar... Or simply wait for user input. Then you want to use yield. And if yield you problems (and it might) I will strongly encourage looking into using signals instead of method calls. You can define your own signals, emit them, connect methods to them. That is not for this answer, just something you might want to look into.
Ok, the other thing:
Another detail is that the 'for' doesn't seem to be working
Look here you are returning on the first iteration:
for n in attacker.row:
dmg_roll += roll(attacker.dice)
print(dmg_roll)
return damage(target, attacker, dmg_roll)
My intuition would be to call damage to be outside of the loop:
for n in attacker.row:
dmg_roll += roll(attacker.dice)
print(dmg_roll)
return damage(target, attacker, dmg_roll)
In fact, damage does not return, and you don't use the return value of turn, so you could also remove the return keyword…
for n in attacker.row:
dmg_roll += roll(attacker.dice)
print(dmg_roll)
damage(target, attacker, dmg_roll)
So if you actually meant to call damage in a loop, you can also do that:
for n in attacker.row:
dmg_roll += roll(attacker.dice)
print(dmg_roll)
damage(target, attacker, dmg_roll)

Answer 2

extends Node2D
var enemy_turn : bool = false
var critical_Hit : bool = false
func _start_combat(player, enemy):
var target
var attacker
while true:
if enemy_turn == false:
target = enemy
attacker = player
else:
target = player
attacker = enemy
turn(target, attacker)
if target.hp <= 0:
target._death()
break
func roll(dice) -> int:
var random_number = RandomNumberGenerator.new()
random_number.randomize()
return random_number.randi_range(1, dice)
func turn(target, attacker):
print(attacker.char_name, " atack ", target.char_name)
var iniciative_roll = roll(20)
print("Iniciative d20: ", iniciative_roll)
if iniciative_roll == 20:
print("Critical Hit!") #Tenho que verificar se eu estou saindo daqui sem passar para baixo visto que 20 >= abs()
critical_Hit = true
elif iniciative_roll >= abs(target.ac - attacker.thac0):
critical_Hit = false
else:
print(attacker.char_name, " miss.")
return
var dmg_roll : int = 0
for n in attacker.row:
dmg_roll += roll(attacker.dice)
print(dmg_roll)
damage(target, attacker, dmg_roll)
func damage(target, attacker, dmg_roll):
if critical_Hit == true:
target.hp -= 2 * dmg_roll
else:
target.hp -= dmg_roll
print(attacker.char_name, " do ", dmg_roll, " damage ", target.char_name)
See the DEBUG:
Player made an attack action...
Jobson atack Globin
Iniciative d20: 2
Jobson miss.
Jobson atack Globin
Iniciative d20: 16
10
Jobson do 10 damage Globin
Jobson atack Globin
Iniciative d20: 5
Jobson miss.
Jobson atack Globin
Iniciative d20: 13
16
Jobson do 16 damage Globin
Globin DIE!
He didn't reverse the turn.
And the curious thing is that precisely, the action occurs instantly. LOL
I didn't think to get around it for now. yield it doesn't seem good to use, it seems to give a lot of bugs.