Mange spil inkluderer en slags fjende at kæmpe med. Udforsk de forskellige måder, du kan tilføje - og finesser - fjendekamp.

Fjender spiller en afgørende rolle i at gøre spil spændende og udfordrende for spillere. Uanset om du opretter et 2D-platformsspil, et top-down skydespil eller et rollespil, kan tilføjelse af fjender forbedre gameplay-oplevelsen markant.

Godots brugervenlige grænseflade og intuitive scriptsprog, GDScript, gør processen effektiv og fornøjelig.

Opsætning af Godot-spillet

Inden du dykker ned i fjendens skabelse, skal du konfigurere den grundlæggende struktur i dit 2D-spil Godot spilmotoren.

Opret et nyt 2D-projekt i Godot. I hovedscenen skal du oprette en ny KinematicBody2D node og navngiv den Spiller. Tilføj en inde i afspillernoden CollisionShape2D med en rektangelform, som vil være spillerens hitbox. Tilføj også en Sprite node som en visuel repræsentation af spillerens karakter.

Koden brugt i denne artikel er tilgængelig i denne GitHub-depot og er gratis for dig at bruge under MIT-licensen.

instagram viewer

Vedhæft følgende GDScript-kode til Spiller node for at aktivere grundlæggende bevægelse:

extends KinematicBody2D
const SPEED = 200


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


if Input.is_action_pressed("ui_right"):
 motion.x += SPEED


if Input.is_action_pressed("ui_left"):
 motion.x -= SPEED


if Input.is_action_pressed("ui_down"):
 motion.y += SPEED


if Input.is_action_pressed("ui_up"):
 motion.y -= SPEED
 motion = move_and_slide(motion)

Med denne kode kan spilleren flytte til venstre, højre, op og ned ved hjælp af piletasterne eller WASD-tasterne.

At skabe en simpel fjende

Nu hvor du har sat en spillerkarakter op, kan du skabe en simpel fjende.

Opret en ny scene og tilføj en StaticBody2D node navngivet Fjende. Tilføj en inde i fjendeknuden CollisionShape2D node med en cirkelform for at definere fjendens hitbox. Tilføj også en Sprite node for at repræsentere fjenden visuelt.

Med kollisionen sat op, vil fjenden være klar til at interagere med spilleren og andre elementer i din spilverden.

Få en fjende til at følge spilleren

At skabe fjender, der følger spilleren, tilføjer et nyt niveau af udfordring til spillet.

Opret en ny scene for følgende fjendetype og tilføj en KinematicBody2D node navngivet Følg fjenden med en CollisionShape2D. Vedhæft følgende GDScript-kode til FollowEnemy-knuden for at få den til at følge afspilleren:

extends KinematicBody2D
const SPEED = 100


func _physics_process(delta):
 var player = get_parent().get_node("Player")
 var player_position = player.global_position
 var enemy_position = global_position
 var direction = player_position - enemy_position
 direction = direction.normalized()
 var motion = direction * SPEED * delta
 move_and_collide(motion)

Nu, den Følg fjenden vil bevæge sig mod spillerens position i hvert billede.

Tilføjelse af fjendens kugler

Nu kan du få fjenden til at skyde kugler mod spilleren. Opret en ny scene og navngiv den Bullet.tscn. Tilføj en KinematicBody2D node til scenen. Vedhæft Bullet.gd script til KinematicBody2D-knuden i Bullet.tscn-scenen. Tilføj følgende kode for at definere Bullet-klassen:

extends KinematicBody2D
const BULLET_SPEED = 300
var bullet_direction = Vector2.ZERO


func _physics_process(delta):
 var motion = bullet_direction * BULLET_SPEED * delta
 move_and_collide(motion)
func set_direction(direction):
 bullet_direction = direction.normalized()

Opret nu en ny node til fjenden med kugler og navngiv den Shooting Enemy. Tilføj en inde i ShootingEnemy-knuden CollisionShape2D node med en rektangelform som hitbox.

Vedhæft følgende GDScript-kode til ShootingEnemy-knuden for at få den til at skyde kugler:

extends KinematicBody2D
const SPEED = 100
const SHOOT_DELAY = 1.5
var shoot_timer = SHOOT_DELAY


# Import the Bullet scene
const BulletScene = preload("res://Bullet.tscn")


func _physics_process(delta):


# Shooting logic
 shoot_timer -= delta
if shoot_timer <= 0:
 shoot_timer = SHOOT_DELAY
 var bullet_instance = BulletScene.instance() 
 bullet_instance.global_position = global_position
 bullet_instance.set_direction(direction) 
 get_parent().add_child(bullet_instance)

Fjenden vil nu med jævne mellemrum skyde kugler mod spillerens position. Brug en betinget hvis udmelding for at kontrollere, om shoot_timer er mindre end 0. Hvis det er, så skyd kuglen.

Tilfældigt bevægende fjende

Ud over fjender, der følger efter eller skyder på spilleren, kan en tilfældigt bevægende fjende injicere et element af uforudsigelighed og udfordring i dit spil. At skabe en fjende med tilfældige bevægelsesmønstre kræver en kombination af simpel logik og generering af tilfældige tal.

Start med at oprette en ny scene og tilføj en KinematicBody2D node navngivet Random Enemy. Opret et nyt script med navnet RandomEnemy.gd og vedhæft den til RandomEnemy-knuden. Scriptet vil håndtere den tilfældige bevægelseslogik.

extends KinematicBody2D
const MOVE_SPEED = 100
const MOVE_INTERVAL_MIN = 1.0
const MOVE_INTERVAL_MAX = 3.0


var move_timer = 0.0
var move_interval = 0.0
var move_direction = Vector2.ZERO


func _ready():
 choose_new_direction()


func choose_new_direction():
 move_interval = rand_range(MOVE_INTERVAL_MIN, MOVE_INTERVAL_MAX)
 move_timer = move_interval
 move_direction = Vector2(randf(), randf()).normalized()


func _physics_process(delta):
 move_timer -= delta


if move_timer <= 0.0:
 choose_new_direction()
 var motion = move_direction * MOVE_SPEED * delta
 move_and_collide(motion)

Inklusiv yderligere funktioner

Der er mange ekstra funktioner, du kan tilføje til dine fjender for at gøre spillet mere interessant.

Boss kampe

Boss-kampe fungerer som klimaksøjeblikke i dit spil og giver mindeværdige og udfordrende møder, der tester spillernes færdigheder og udholdenhed. Boss-fjender er typisk større og mere magtfulde end almindelige fjender, hvilket kræver, at spillere anvender specifikke strategier og taktikker for at besejre dem.

Dynamisk fjende-gydning

Implementer et dynamisk spawning-system, der justerer fjendens møder baseret på spillerens præstation, placering eller begivenheder i spillet. Dette skaber en mere lydhør og personlig gameplayoplevelse.

Miljøtilpasning

Skab fjender, der kan tilpasse sig miljøet, såsom fjender, der kan flyve, svømme eller klatre på vægge. Denne alsidighed åbner op for nye gameplay-muligheder og udfordrer spillere til at navigere i forskellige terræner.

Fjendens svagheder og modstand

Tildel specifikke svagheder og modstande til fjender, og tilskynd spillerne til at eksperimentere med forskellige tilgange og taktikker. Nogle fjender kan være sårbare over for visse angreb eller elementer, mens andre er immune eller resistente.

Fjendtlig tilpasning og adfærdsvariationer

Tilføj et niveau af uforudsigelighed ved at give fjender randomiserede adfærdsvariationer. For eksempel kan en fjende have forskellige angrebsmønstre eller bevægelseshastigheder i forskellige gennemspilninger, hvilket holder gameplayet friskt og kan genspilles.

At inkludere en række af disse ekstra funktioner kan berige dit spils fjendedesign, hvilket gør hvert møde unikt og mindeværdigt for spillere.

Husk, at selvom det kan være spændende at introducere ny mekanik, er det afgørende at bevare balancen og sammenhængen i dit spils overordnede design.

Bedste fremgangsmåder til at skabe fjender

Når du opretter fjender i dit Godot-spil, skal du overveje følgende bedste praksis:

Klar visuel kommunikation

Brug særskilte fjendedesigns, der skiller sig ud fra omgivelserne for at gøre fjender let genkendelige.

Overvej at bruge farvekodning eller unikke silhuetter for at skelne fjendens typer. Sørg for, at fjendens animationer og visuelle effekter forstærker deres adfærd og angreb.

Balanceringsbesvær

Introducer gradvist fjender med stigende kompleksitet, efterhånden som spilleren skrider frem gennem spillet. Test fjendens møder med spillere på forskellige færdighedsniveauer for at sikre, at udfordringer er egnede til alle spillere. Undgå pludselige sværhedsgrader, der kan frustrere spillere.

Undgå billige skud

Design fjender med angreb, som spilleren kan undvige eller blokere, hvilket giver dem en chance for at reagere. Brug en fair hitbox til fjenders angreb, undgå angreb, der rammer ud over deres visuelle repræsentation. Brug advarselsskilte eller signaler til at antyde farlige angreb.

Playtesting og iteration

Test jævnligt fjendens møder under udvikling for at evaluere deres sjove faktor og sværhedsgrad. Indsaml feedback fra spillere og brug den til at finjustere fjendens adfærd, styrker og svagheder.

Lydeffekter

Lydeffekter spiller en afgørende rolle i at skabe et fordybende og fængslende spilmiljø. Når en fjende tager et slag, skal du tilføje passende ophavsretsfri lydeffekter at forstærke følelsen af ​​påvirkning og engagement i kamp.

Dit spil kan ledsage hvert angreb eller slag med forskellige lydsignaler, der svarer til angrebstypen og fjendens karakteristika.

Gør Godot-spil mere engagerende med fjender

Fjender er en grundlæggende komponent i mange spil, der giver udfordringer, forhindringer og en følelse af præstation, når de bliver besejret. Ved at tilføje forskellige typer fjender med varierende adfærd, sundhedspoint og skydemekanik kan du skabe forskellige og engagerende spiloplevelser for spillere.

Husk at balancere sværhedsgraden, give visuel og auditiv feedback, og test dine fjender grundigt for at give spillerne en fornøjelig og givende spiloplevelse.