Optimizations for Bullet Hell-like games

VanyelTeam

I'm new to Godot and had only made 2 games so far, and I want to optimize my bullet hell game.

Old Setup for bullets:

Area2D with Physics Collision Nodes
With Animation, Sprite, and Particle Nodes attached for each bullet
Result: 160 Max before FPS drops

Current setup for bullets:

Sprite2D Bullets with Distance Squared Comparison checking done in a Bullet Manager
Bullets are pooled as well
Despawning: visibility turned off with movement variables being reset
Bullet Movement and Logic is done inside each bullet
Just one Sprite2D
300-400 Max before FPS drops

Goal:

1000-2000 Bullets
With unique movement calculations plausible as well

Extra information:

Uses Compatibility+
Designed as a Vertical Shooter for Mobile Games
I'm using Godot 4.3 for Android

What can I do to improve this? I feel like I've done the best I could.

xyz

VanyelTeam Profile to determine bottlenecks. You can try to get rid of nodes. How do you handle collisions?

VanyelTeam

xyz I'm on Godot 4.3 for Android... Profiling is difficult as running the game isn't on a separate Window...

here's how I do collisions currently, results are 400-500 Bullets at 30-60 FPS

const BROAD_RADIUS: float = 120.0
const GRAZE_RADIUS: float = 100.0
const HURT_RADIUS: float = 8.0
const SHIELD_RADIUS: float = 80.0
const WAVE_RADIUS: float = 40.0

func physics_process(delta: float) → void:
check_collisions()

func check_collisions() → void:
if not is_instance_valid(GameManager.player):
return

for b: EnemyBullet in active_enemy_bullet_pool:
if not is_instance_valid(b):
continue

var player_distance: float = GameManager.player.global_position.distance_squared_to(b.global_position)

var graze_r: float = GRAZE_RADIUS + b.collision_size()
var inside_graze: bool = player_distance <= graze_r * graze_r
if inside_graze and not b.has_grazed:
	GameManager.player.graze_increase(1)
	b.has_grazed = true
elif not inside_graze and b.has_grazed:
	b.has_grazed = false

var hurt_r: float = HURT_RADIUS + b.collision_size()
var inside_hurt: bool = player_distance <= hurt_r * hurt_r
if inside_hurt and not b.has_hit_player:
	GameManager.player.damaged(b.damage_player())
	b.has_hit_player = true
elif not inside_hurt and b.has_hit_player:
	b.has_hit_player = false

var broad_r: float = BROAD_RADIUS + b.collision_size()

if is_instance_valid(GameManager.shield) and GameManager.shield.enabled == true:
	var shield_distance: float = GameManager.shield.global_position.distance_squared_to(b.global_position)

	var shield_r: float = SHIELD_RADIUS + b.collision_size()
	var inside_shield: bool = shield_distance <= shield_r * shield_r
	if inside_shield and not b.has_been_reflected:
		var shield_result: bool = b.shield_reflected(GameManager.shield.global_position)
		if shield_result == false:
			GameManager.shield.destroyed()
		b.has_been_reflected = true
	elif not inside_shield and b.has_been_reflected:
		b.has_been_reflected = false

	if shield_distance > broad_r * broad_r:
		continue

if player_wave_bullet_pool.size() > 0:
	for pb: PlayerBullet in player_wave_bullet_pool:
		var wave_distance: float = pb.global_position.distance_squared_to(b.global_position)
		var wave_r: float = WAVE_RADIUS + b.collision_size()
		var inside_wave: bool = wave_distance <= wave_r * wave_r
		if inside_wave and not b.has_been_slowed:
			b.movement_slowed(200.0, Vector2.UP)
			b.has_been_slowed = true
		elif not inside_wave and b.has_been_slowed:
			b.has_been_slowed = false

if player_distance > broad_r * broad_r:
	continue

kuligs2

xyz For 3d we have RenderServer class to instantiate meshes but for 2D how can you get rid of the nodes?

axolotl

VanyelTeam

A few suggestions:

move the test "if distance_sq>broad**2 then continue" to be the first thing in the loop instead of the last
precompute broad*broad once rather than once per iteration.

xyz

kuligs2 RenderingServer does 2D as well. Look at the class reference. There's a bunch of canvas_item_*() functions.

JusTiCe8

Hi,

from 160 to 300-400 with pooling is very weird ! It should be a lot more so there is one or more concern(s) with your code.

Do you use dynamic data structure ? I mean array especially with variable size and append/pop methods usage ?
If yes => BAN this, it's a nightmare for performance.

maxvolumegames

This might give you some ideas: https://github.com/Griiimon/Manymies

JusTiCe8

axolotl precompute broad*broad once rather than once per iteration.

not sure it will improve so much, simple mult, use twice and there are other such mult use once or twice, this kind of stuff may be already inlined by the engine or even deeper by some runtime optimizations.

Still, it needs to be benchmarked to be 100% sure, nothing better than doing our own due dilligence testing.