Kollisionsdetektering påverkar de flesta delar av ditt spel, från hur din spelare står på en plattform till hur de förstör fiender.

Kollisionsdetektering är en av de kritiska aspekterna av spelutveckling, som avsevärt påverkar spelarupplevelsen. Exakt kollisionsdetektering säkerställer att spelkaraktärerna interagerar sömlöst med sin omgivning, vilket skapar en känsla av fördjupning och realism.

Godot, en populär spelmotor med öppen källkod, tillhandahåller kraftfulla verktyg för att implementera effektiv kollisionsdetektering, vilket resulterar i smidigt och engagerande spel.

Konfigurera Godot-spelet

Innan du börjar, skapa ett enkelt 2D-plattformsspel i Godot 4. Börja med att ställa in spelscenen med en spelarkaraktär och plattformar.

Koden som används i den här artikeln är tillgänglig i denna GitHub-förråd och är gratis för dig att använda under MIT-licensen.

Skapa en ny scen och lägg till en CharacterBody2D nod som rotnod. Lägg till en Sprite2D nod som ett barn till CharacterBody2D för att visuellt representera spelarkaraktären.

instagram viewer

Nästa, lägga till rörelse till spelaren tecken med GDScript:

extends CharacterBody2D
var speed = 300


func _physics_process(delta):
 var input_dir = Vector2.ZERO


if Input.is_action_pressed("ui_left"):
 input_dir.x -= 1


if Input.is_action_pressed("ui_right"):
 input_dir.x += 1


if Input.is_action_pressed("ui_up"):
 input_dir.y -= 1


if Input.is_action_pressed("ui_down"):
 input_dir.y += 1
 velocity = input_dir.normalized() * speed
 move_and_collide(velocity * delta)

Lägg slutligen till plattformar till scenen med hjälp av StaticBody2D noder för att slutföra den grundläggande installationen.

Olika kollisionsformer

Godot tillhandahåller en mängd olika kollisionsformer som passar olika typer av spelobjekt. Dessa kollisionsformer hjälper till att exakt definiera området inom vilket kollisionsdetektering äger rum.

Innan du dyker in i de olika kollisionsformerna är det viktigt att notera att du kan fästa en direkt på spelarkaraktären för att definiera dess kollisionsområde. Detta låter dig kontrollera det exakta området för att upptäcka kollision.

Cirkelkollisionsform

En cirkelkollisionsform är särskilt användbar för karaktärer som behöver interagera med omgivningen radiellt. Du kan använda den här formen för tecken med en cirkulär eller sfärisk hitbox. Så här lägger du till en cirkelkollision till din spelarkaraktär:

# Inside the player character's script
var collision_shape = CollisionShape2D.new()
var circle_shape = CircleShape2D.new()
circle_shape.radius = 32
collision_shape.shape = circle_shape
add_child(collision_shape)

rektangel kollision form

Rektangulära kollisionsformer är lämpliga för tecken med en mer boxig eller rektangulär form. Så här kan du lägga till en rektangelkollision:

# Inside the player character's script
var collision_shape = CollisionShape2D.new()
var rect_shape = RectangleShape2D.new()
rect_shape.extents = Vector2(32, 64)
collision_shape.shape = rect_shape
add_child(collision_shape)

Konvex polygonkollisionsform

Konvexa polygonkollisionsformer ger stor flexibilitet för tecken med oregelbundna eller icke-rektangulära former. Du kan använda den här formen för att matcha konturerna av din karaktär. Så här lägger du till en konvex polygonkollisionsform:

# Inside the player character's script
var collision_shape = CollisionShape2D.new()
var polygon_shape = ConvexPolygonShape2D.new()
polygon_shape.set_points([Vector2(-32, -64), Vector2(32, -64), Vector2(0, 64)])
collision_shape.shape = polygon_shape
add_child(collision_shape)

Genom att välja lämplig kollisionsform och fästa den på spelarkaraktären kan du exakt upptäcka kollisioner inom det angivna området, vilket förbättrar noggrannheten i interaktioner med spelet värld.

Upptäck kollisioner

Att upptäcka kollisioner mellan objekt är viktigt för att implementera interaktioner och spelmekanik. I Godot kan du uppnå detta med den inbyggda fysikmotorn.

# Detecting Collisions in _physics_process
func _physics_process(delta):
 var input_dir = Vector2.ZERO
#... (input handling)
 velocity = input_dir.normalized() * speed
 var collision = move_and_collide(velocity * delta)
if collision:
 print("collided")

Nedan är utgången:

Kollisionssignaler och kollisionsmasker

Godot tillhandahåller kollisionssignaler och kollisionsmasker som kraftfulla verktyg för att lägga till sofistikering till ditt spel.

Kollisionssignaler

Kollisionssignaler är händelser som fysikmotorn utlöser när kollisioner inträffar. Dessa signaler ger ett sätt för objekt att kommunicera med varandra och reagera på kollisioner. I Godot kan du ansluta till kollisionssignaler för att exekvera anpassad logik när specifika kollisionshändelser äger rum.

Säg till exempel att du vill spela en ljudeffekt när spelarkaraktären kolliderar med ett samlarobjekt. Så här kan du uppnå detta med hjälp av kollisionssignaler:

# Inside the player character's script
func _ready():
 connect("body_entered", self, "_on_body_entered")
func _on_body_entered(body: Node):
if body.is_in_group("collectible"):
# Play a sound effect
 play_collectible_sound()


# Perform additional logic like collecting the item
# Remove the collectible from the scene
 body.queue_free()

I det här exemplet är body_entered signal sänds ut när spelarkaraktären kolliderar med en annan fysikkropp. Genom att ansluta denna signal till _on_body_entered funktion kan du svara på kollisionshändelsen. Om den kolliderande kroppen är i samlarobjekt grupp, du kan spela upp en upphovsrättsfri ljudeffekt.

Kollisionsmasker

Kollisionsmasker låter dig styra vilka kollisionslager som kan interagera med varandra. Varje kollisionslager motsvarar en bit i en bitmask. Genom att tilldela kollisionslager och masker till objekt kan du finjustera vilka objekt som kolliderar med varandra och optimera prestandan.

Föreställ dig till exempel att du har fiender och kulor i ditt spel. Du vill att fiender ska kollidera med plattformar men inte med varandra. Du vill också att kulor ska kollidera med fiender men inte med plattformar. Så här kan du uppnå detta med hjälp av kollisionsmasker:

# Inside the enemy's script
func _ready():
# Disable collision with other enemies
 set_collision_mask_value(2, false)

# Enable collision with platforms
 set_collision_mask_value(3, true)
# Inside the bullet's script
func _ready():
# Enable collision with enemies
 set_collision_mask_value(2, true)
# Disable collision with platforms
 set_collision_mask_value(3, false)

Genom att selektivt aktivera eller inaktivera kollisionsmasker styr du vilka objekt som kan kollidera med varandra, vilket resulterar i exakta och effektiva kollisionsinteraktioner.

Bästa metoder för kollisionsdetektering

För att säkerställa smidigt spelande och effektiv kollisionsdetektering, överväg dessa bästa metoder.

Använd enkla former

Komplexa kollisionsformer kan vara resurskrävande. När det är möjligt, använd enkla former som cirklar och rektanglar för kollisionsdetektering.

Lagerkollisionsmasker

Godot låter dig definiera kollisionslager och masker. Använd dessa för att styra vilka objekt som kolliderar med varandra, vilket optimerar prestandan.

Till exempel, i ett plattformsspel, spelare kan hoppa på plattformar och glida längs väggar. Genom att ställa in kollisionslager och masker på lämpligt sätt kan du uppnå distinkta beteenden.

Kollisionsgrupper

Gruppera objekt med liknande kollisionsegenskaper för enklare hantering och effektiv kollisionsdetektering.

Avgränsande lådor

För prestandaoptimering, använd begränsningsrutor för att snabbt kontrollera om objekt finns i närheten innan du utför exakt kollisionsdetektering.

Använd kinematiska frågor

Godot tillhandahåller kinematiska frågor för att utföra kollisionskontroller utan att faktiskt flytta objektet. Detta kan vara användbart för att förutsäga kollisioner innan de inträffar.

Gör Godot-spel mer engagerande med kollisionsdetektering

Att integrera effektiv kollisionsdetektering i ditt Godot-spel säkerställer inte bara sömlös interaktion mellan karaktärer och omgivningen men öppnar också möjligheter för kreativt spelande mekanik.

Oavsett om det är plattformsutmaningar, pussellösning eller stridsscenarier är kollisionsdetektering kärnan i spelarens engagemang. Genom att lägga till kollisionsdetektering kan du skapa ett spel som fängslar spelare med sina smidiga och dynamiska interaktioner.