In diesem Artikel werde ich die Funktionen der Arbeit in drei Spiel-Engines am Beispiel des Schreibens von Code für ein spinnenartiges Fahrzeug erläutern.
Die allgemeine Struktur des "Spinnenwagens" war wie folgt: Es gibt 6 Pfoten, jede Kopie des Kontrollskripts, die die Bewegung der Hauptstruktur verfolgen und die Pfote in eine neue Position bringen, wenn sie sich eine bestimmte Strecke entfernt.
Für eine genauere Landung der Pfoten war geplant, Raycasts hinzuzufügen, aber zum Beispiel wollte ich in demselben Godot eine Spinne für ein Spiel mit einer Draufsicht herstellen, bei dem eine solche Genauigkeit nicht besonders benötigt wird.
Daher bestand die Aufgabe darin, die gewünschte Struktur innerhalb des Motors zu bilden und den Code für einen separaten Fuß zu schreiben. Folgendes ist in verschiedenen Entwicklungsumgebungen passiert:
Godot
Hier hatte ich bereits ein kleines Projekt mit Autos und einer Spinne fertig. Ich beschloss, eine der Szenen (Fertighäuser) zu ergänzen, die eine Unterklasse von Autos ohne Räder enthält.
Die spezifische_Basis-Szene selbst ist so angeordnet, dass sich an der Basis ein Dummy-Knoten befindet, der einfach irgendwo auf der Welt hängt, ohne sich zu bewegen, und der kinematische Körper in ihm bewegt sich um die Welt. Die Kamera befindet sich innerhalb der Szene, aber außerhalb des Körpers, indem Sie ihr folgen.
Um die Spinne zu erstellen, habe ich einen separaten Knoten im Körper hinzugefügt, der Dummy-Punkte für die Position der Pfoten enthält (wo sie auf dem Boden platziert sind, nicht dort, wo sie am Körper befestigt sind).
Der Einfachheit halber habe ich die Pfoten selbst hier in dieser Szene platziert, aber außerhalb des Körpers. Das Skript, das jeden von ihnen steuert, überträgt die Pfote zusätzlich zur Übertragung ständig in die Mitte der "Spinne".
Code im Godot-Editor
Schreiben des Codes. Ich benutze GDScript, weil ich nicht viel Sinn darin sehe, in C # in Godot zu schreiben (nicht so sehr ein Fan von geschweiften Klammern):
extends Spatial
export var distance = 2.5# ,
export var step = 1# ( )
# ,
export (NodePath) var spidercenter = null
var trg_center
export (NodePath) var spiderleg = null
var trg_leg
# x z
var x_dis = 0.0
var z_dis = 0.0
#-,
var time_lag = -1.0
#
func _ready():
self.hide()#
trg_center = get_node(spidercenter)#
trg_leg = get_node(spiderleg)
LegPlace()#
#
func _process(delta):
# . ,
self.look_at(trg_center.global_transform.origin, Vector3(0,1,0))
# , . , , ( , ). LegPlace
if self.visible == false: self.show()
if time_lag>=0:# - ,
time_lag +=1*delta
if time_lag>0.06:#
time_lag = -1.0
LegPlace()
else:#
x_dis = abs(trg_leg.global_transform.origin.x - self.global_transform.origin.x)
z_dis = abs(trg_leg.global_transform.origin.z - self.global_transform.origin.z)
if (x_dis + z_dis) > distance:# ,
time_lag = 0.0
pass
func LegPlace():#,
self.hide()
step = step*(-1)
self.global_transform.origin = trg_leg.global_transform.origin+Vector3(0,0,0.5*step)
Godot Spinnenteig Zwischensequenz. Als Bonus enthielt es auch Momente aus einem separaten Spiel mit Terraforming der Voxelwelt, in dem auch eine "Spinne" verwendet wird, die jedoch rein animiert ist, sowie eine Demo mit Autos auf Playcanvas, bevor die Spinnenform dort hinzugefügt wurde.
Unigine
Nachdem die Implementierung für Godot fertig war, entschied ich mich, diese Lösung auf die Unigine-Engine zu portieren. Dort hatte ich auch ein Projekt mit Autos , aber um es nicht zu überladen, habe ich eine separate "Spinnen" -Gabel gemacht, damit ich später wahrscheinlich die Räder komplett davon entfernen und es irgendwie separat entwickeln kann.
Es gibt die gesamte Szene der Spielwelt, in der sich die Karosserie des Autos des Spielers befindet. Zu Beginn des Spiels werden separat angeordnete Räder an diesen Körper angedockt.
Ich suche nach einem Dummy im Körper, in dem sich Punkte befinden, die die Positionen der Pfoten festlegen.
Die Pfoten werden einfach in die Spielwelt gelegt. Die Bewegung selbst wird durch die Räder realisiert, aber ihre visuelle Darstellung ist deaktiviert.
Unigine startet externe Umgebung für die Codebearbeitung
Code:
using System;// ""
using System.Collections;
using System.Collections.Generic;
using Unigine;
// ,
[Component(PropertyGuid = "5a8dd6f85781adf7567432eae578c5414581ddac")]
public class theLegBehavior : Component
{
[ShowInEditor][Parameter(Tooltip = "CenterSpider")]//
private Node spiderCenter = null;
[ShowInEditor][Parameter(Tooltip = "Target Leg Point")]//
private Node legPoint = null;
//
private float x_dis= 0.0f;
private float z_dis= 0.0f;
private float ifps;//
private float time_lag = -1.0f;//-
private void Init()//
{
node.Enabled = false;//
LegPlace();//
}
private void Update()//
{
ifps = Game.IFps;//
if (time_lag>=0.0f){//
time_lag += 1.0f*ifps;
if (time_lag>=0.6f) {
time_lag = -1.0f;
LegPlace();
}
}else{
x_dis = MathLib.Abs(legPoint.WorldPosition.x - node.WorldPosition.x);
z_dis = MathLib.Abs(legPoint.WorldPosition.z - node.WorldPosition.z);
if (x_dis + z_dis > 0.8f){
time_lag = 0.0f;
}
}
}
// . . . , , , - . , Update.
private void LegPlace()
{
node.Enabled = false;
vec3 targetDirection = vec3.ZERO;
targetDirection = (legPoint.WorldPosition - node.WorldPosition);
quat targetRot = new quat(MathLib.LookAt(vec3.ZERO, targetDirection, vec3.UP, MathLib.AXIS.Y));
quat delta = MathLib.Inverse(targetRot);
delta.z = 0;
delta.Normalize();
node.WorldPosition = legPoint.WorldPosition;
targetDirection = (spiderCenter.WorldPosition - node.WorldPosition);
node.SetWorldDirection(targetDirection, vec3.UP, MathLib.AXIS.Y);
node.Enabled = true;
}
}
Unigine Spider Dough Cutscene
PlayCanvas
PlayCanvas ist eine WebGL-Spiel-Engine, die Javascript verwendet. Vor kurzem habe ich angefangen, es zu verstehen. Es sieht aus wie eine Kreuzung zwischen Unity und Godot, aber bei der Online-Entwicklung wird der Editor im Browser geöffnet.
In diesem Fall habe ich eines der Beispiele dieser Plattform überarbeitet und einige meiner Automodelle hinzugefügt, einige zusätzliche Funktionen wie Springen, Hinzufügen einer Kamera und Spielen mit Materialien / Einstellungen.
Die visuelle Darstellung des Basiswagens im ursprünglichen Beispiel wurde durch ein solides Modell gegeben, das ich teilweise deaktiviert habe, wobei nur die Räder übrig blieben, die von seinem Steuerungsskript aus dem Inneren des Modells gezogen werden (dh sie werden nicht von separaten Knoten in der Szenenhierarchie gewickelt). Diese visuelle Darstellung während des Spiels hängt an einem sich bewegenden physischen Radmodell.
Um die "Spinne" in diesem Projekt zu implementieren, habe ich ein "Spinnenzentrum" in der visuellen Darstellung des Autos gestartet. Der Einfachheit halber ist der "Spinnenkörper" darin verschachtelt, weil ich sofort zur "Spinnenform" und zurück wechseln wollte.
Somit wird die lokale "Spinne" auch oben auf dem Radantrieb platziert und die Räder selbst sind verborgen. Vielleicht wäre es richtiger, den Spinnenrahmen am Physikknoten anzubringen, aber das Wechseln zwischen Formularen befindet sich bereits im Skript des Knotens mit der visuellen Darstellung des Autos, und andere Modelle befinden sich in diesem Knoten. Daher habe ich diese Option der Einfachheit halber gewählt. Tatsächlich stellt sich heraus, dass sich das Bild in seinem Skript hinter der Physik bewegt und die Skripte der Pfoten bereits auf den Spinnenrahmen schauen, der sich zusammen mit dem Bild bewegt. Theoretisch kann es hier zu einer Desynchronisation kommen, zumindest habe ich festgestellt, dass einige Pfoten auf schwachen Geräten keine Zeit haben, Positionen zu berechnen, und nur einige Bewegungen.
Und so ist die Lösung im Allgemeinen natürlich nicht an die Physik oder den starren Körper gebunden. Den Beinen ist es in der Tat egal, wie Sie das Hauptobjekt bewegen - durch Kräfte oder einfach durch Ändern der Position.
Die Pfoten befinden sich in der Szene selbst, aber zum bequemen Aktivieren / Deaktivieren werden sie in einem separaten Knoten gesammelt, sodass Sie sie einfach deaktivieren können und nicht jeweils über einen separaten Link.
In playcanvas wird der Code-Editor in einem neuen Browser-Tab
Code gestartet :
var TheLegBehavior = pc.createScript('theLegBehavior');
//
TheLegBehavior.attributes.add('N_spiderCenter', { type: 'entity' });
//
TheLegBehavior.attributes.add('N_legPoint', { type: 'entity' });
//
this.x_dis = 0.0;
this.z_dis = 0.0;
this.time_lag = -1.0;//-
// , , -
TheLegBehavior.prototype.initialize = function() {
};
//
TheLegBehavior.prototype.update = function(dt) {
if (this.N_spiderCenter) {// -
this.entity.lookAt(this.N_spiderCenter.getPosition());// ,
}
};
//. , , , , .
TheLegBehavior.prototype.postUpdate = function(dt) {
//,
if (time_lag>=0.0){
time_lag+=1.0*dt;
if (time_lag>=0.06){
time_lag=-1.0;
this.LegUpdate();
}
} else {
x_dis = Math.abs(this.entity.getPosition().x-this.N_legPoint.getPosition().x);
z_dis = Math.abs(this.entity.getPosition().z-this.N_legPoint.getPosition().z);
if ((x_dis+z_dis)>3.0){
time_lag=0.0;
}
}
};
// , ", , ",
TheLegBehavior.prototype.LegUpdate = function() {
if (this.N_legPoint) {// , ,
this.entity.setPosition(this.N_legPoint.getPosition());
}
};
Im Allgemeinen haben wir bisher eine leere Spinne mit vier Beinen und nicht ganz optimalen Berechnungen erhalten.
Sie können die resultierenden Rahmen testen
hier .
Ich persönlich habe versucht, über Chrome und Dolphin auf einem nicht zu leistungsstarken Smartphone zu laufen. Die Grafiken ähneln PsOne und die Berechnungen für einige Pfoten funktionieren nicht, während die Ebene auf dem Bildschirm sichtbar ist und die Pfoten am Rand der Karte angezeigt werden. Auf einem schwachen Laptop gab es in Chrome sehr starke Bremsen, aber in Firefox läuft alles einwandfrei. Auf einem Laptop mit einer diskreten Grafikkarte und auf einem stationären Gerät fliegt es in beiden Browsern.
Auf einem PC führt diese Demo im Gegensatz zu Smartphones einen Sprung aus (durch Drücken der Leertaste), bereitet eine Strafe vor (Q und E) und lädt ein Level neu (auf R).
Ergebnis
Wie Sie sehen können, sind Sprachen und Engines unterschiedlich, aber dennoch werden viele Dinge in der Familie der Skriptsprachen auf ähnliche Weise ausgeführt. Wie oft haben Sie neue Spiel-Engines und Frameworks gemeistert, was waren die Hauptschwierigkeiten, mit denen Sie konfrontiert waren?