Hur man skapar nivåer i Godot-spel

av

Att skapa nivåer är en avgörande aspekt av speldesign som avsevärt kan förbättra ditt spels övergripande attraktionskraft. Nivåer ger strukturen och utmaningarna som håller spelarna engagerade och motiverade att gå vidare genom ditt spel.

Genom att noggrant skapa väldesignade nivåer kan du skapa en mer uppslukande och njutbar upplevelse för dina spelare. Oavsett om du är nybörjare eller en erfaren spelutvecklare gör Godot det enkelt att skapa fängslande nivåer som får spelare att komma tillbaka för mer.

Konfigurera Godot-spelet

Innan du börjar skapa nivåer är det viktigt att du ställer in ditt 2D-spelprojekt i Godot Game Engine.

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 Node2D-nod som rotnod. Detta kommer att fungera som behållare för alla andra noder i din scen. Nu när ditt projekt är konfigurerat är det dags att lägga till spelarkaraktären till scenen.

Skapa en ny scen genom att högerklicka på scenpanelen och välja New Scene. Lägg till en CharacterBody2D-nod för att representera spelarkaraktären. CharacterBody2D-noden har inbyggda funktioner för rörelse- och kollisionsdetektering för 2D-tecken.

Inuti CharacterBody2D-noden lägger du till en CollisionShape2D-nod med en rektangelform och en Sprite-nod för att representera spelarens utseende.

Med spelarkaraktären och dess bilder inställda kan du nu fokusera på att skapa din första nivå.

Skapa två nivåer

För att skapa nivåer i Godot kan du använda scenfiler (.tscn) för att representera varje nivå separat. Med två nivåer kan du implementera unika layouter och rörliga plattformar.

Spelarkod

CharacterBody2D-skriptet ansvarar för att hantera spelarens rörelse baserat på användarinmatning. I det medföljande GDScript kan du beräkna rörelseriktningen baserat på knapptryckningar och ställa in spelarens hastighet därefter.

Spelarens hastighet avgör hur snabbt de rör sig, och move_and_collide-funktionen tar hand om kollisionsdetektering.

 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)

Plattformskod

Plattformsskriptet utökar StaticBody2D, vilket innebär att plattformen inte kommer att flytta om du inte använder en rörelse på den. I det här fallet kan du använda variabeln move_speed för att styra hur snabbt plattformen rör sig.

Plattformen rör sig fram och tillbaka horisontellt inom det specificerade området (100 till 400 enheter i det här exemplet). När den når kanten ändrar den sin rörelseriktning.

 
extends StaticBody2D
const move_speed = 100
var move_direction = Vector2(1, 0)
func _physics_process(delta):
    var platform_movement = move_direction * move_speed * delta
    translate(platform_movement)
    
    if position.x > 400 or position.x < 100:
        move_direction *= -1

Med dessa skript kan du skapa intressanta rörelsemönster för plattformar och designa engagerande spelupplevelser i dina plattformsspel.

Anslutande nivåer

I ett typiskt spel vill du att spelare ska gå vidare från en nivå till en annan sömlöst. För att göra det, implementera ett Level Manager-skript som hanterar nivåväxling när spelaren passerar skärmgränsen.

Level Manager-skriptet håller reda på det aktuella nivånumret och skärmstorleken. Den laddar den initiala nivån (nivå 1) under _ready(). Funktionen load_level tar ett nivånummer som indata, konstruerar sökvägen till motsvarande scenfil och instansierar nivåns scen.

Lägg till den nya nivån som ett barn till nivåhanteraren; detta ändrar effektivt den aktuella nivån.

 extends Node2D
var level_number = 1
var screen_size = Vector2()
var is_switching_level = false
func _ready():
    screen_size = get_viewport_rect().size
    load_level(level_number)
func load_level(level):
    var level_path = "res://Level" + str(level) + ".tscn"
    var level_scene = load(level_path)
    var level_instance = level_scene.instantiate()
    add_child(level_instance)
    is_switching_level = false
func switch_level():
    if is_switching_level:
        return
    is_switching_level = true
    level_number += 1
    if level_number > 2:
        level_number = 1
    
    var player = get_node("Node2D/Player")
    if player:
        var player_position = player.position
        if player_position.x < 0:
            player.position.x = screen_size.x
        elif player_position.x > screen_size.x:
            player.position.x = 0
        elif player_position.y < 0:
            player.position.y = screen_size.y
        elif player_position.y > screen_size.y:
            player.position.y = 0
    get_node("Node2D").queue_free()
    load_level(level_number)
func _process(delta):
    
    
    var player = get_node("Node2D/Player")
    if player:
        var player_position = player.position
        var condition1 = player_position.x < 0
        var condition2 = player_position.x > screen_size.x
        var condition3 = player_position.y < 0
        var condition4 = player_position.y > screen_size.y
        if condition1 or condition2 or condition3 or condition4 :
            switch_level()

Genom att implementera Level Manager kan du sömlöst växla mellan nivåer och underhålla spelardata över nivåer, vilket säkerställer en smidig spelupplevelse.

Inklusive ytterligare funktioner

Genom att skapa nivåer kan du lägga till olika funktioner i ditt spel, vilket gör det mer engagerande och spännande för spelare.

Samlarföremål

Lägg till samlarobjekt som mynt, stjärnor eller nycklar som spelare kan samla för att låsa upp nya områden eller ta emot belöningar. Samlarföremål uppmuntrar till utforskning och lägger till ett lager av utmaningar till spelet.

Fiender

Presentera fiender med olika beteenden och rörelsemönster. Fiender skapar hinder för spelaren att övervinna, vilket lägger till strategi och spänning till spelet.

Power-ups

Inkludera power-ups som tillfälligt ökar spelarens förmågor, som ökad hastighet, oövervinnerlighet eller förbättrade attacker. Power-ups ger ögonblick av egenmakt och kan hjälpa spelare att övervinna utmanande avsnitt.

Pussel

Designa pusselelement som spelarna måste lösa för att gå vidare genom nivån. Pussel lägger till en cerebral aspekt till spelet och kan få spelare att känna sig fulländade när de räknar ut dem.

Genom att införliva dessa ytterligare funktioner i dina nivåer kan du skapa en rik och varierad spelupplevelse som fängslar spelare och håller dem nedsänkta i din spelvärld.

Bästa metoder för att skapa nivåer

När du skapar nivåer kan att hålla vissa bästa praxis i åtanke hjälpa till att säkerställa en välgjord och njutbar upplevelse för spelare:

Balanssvårigheter

Upprätthåll en jämn svårighetskurva genom hela dina nivåer. Öka gradvis utmaningarna för att hålla spelarna engagerade utan att överväldiga dem. Introducera nya mekaniker och utmaningar gradvis, så att spelare kan anpassa sig och lära sig.

Uppmuntra utforskning

Designa nivåer med dolda vägar, hemligheter och valfria områden för spelare att utforska. Utforskning belönar spelare med bonusar, samlarföremål eller genvägar, vilket ger djup till spelet.

Testning och iteration

Speltesta dina nivåer utförligt för att identifiera eventuella problem, buggar eller obalanser. Iterera på nivådesignen baserat på spelarfeedback för att förbättra den övergripande upplevelsen.

Bild och ljud

Var uppmärksam på de visuella och ljudaspekterna av dina nivåer. Engagerande grafik och upphovsrättsfria ljudeffekter kan avsevärt bidra till atmosfären och fördjupningen i ditt spel.

Nivåflöde

Se till att nivåflödet är jämnt och logiskt. Guide spelare genom nivån med tydliga visuella signaler och undvik återvändsgränder eller förvirrande layouter.

Genom att följa dessa bästa praxis kan du skapa nivåer som inte bara är roliga att spela utan också väldesignade och sammanhängande inom ramen för ditt spel.

Nivåer gör dina Godot-spel mer engagerande

Nivåer spelar en avgörande roll för att göra Godot-spel mer engagerande för spelare. Väldesignade nivåer ger en känsla av progression, prestation och utforskning, vilket lockar spelare att fortsätta spela.

Genom att förstå principerna för nivådesign, utnyttja Godots kapacitet och implementera ytterligare funktioner kan du skapa nivåer som fängslar spelare och lyfter ditt spel till nya höjder.