En este artículo, repasaré las características de trabajar en tres motores de juego, usando el ejemplo de escritura de código para un vehículo arácnido.
La estructura general del "coche araña" se asumió de la siguiente manera: hay 6 patas, cada copia del guión de control, que rastrea el movimiento de la estructura principal y mueve la pata a una nueva posición cuando se aleja a cierta distancia.
Para un aterrizaje más preciso de las patas, se planeó agregar raycasts, pero, por ejemplo, en el mismo Godot, quería hacer una araña para jugar con una vista superior, en la que tal precisión no es particularmente necesaria.
Por lo tanto, la tarea fue formar la estructura deseada dentro del motor y escribir el código para un pie separado. Esto es lo que sucedió en diferentes entornos de desarrollo:
Godot
Aquí ya tenía listo un pequeño proyecto con autos y una araña , decidí agregar a una de las escenas (prefabricados), que contiene una subclase de autos que no tienen ruedas.
La escena de specific_base en sí está organizada de tal manera que en la base hay un nodo ficticio que simplemente cuelga en algún lugar del mundo, sin movimiento, y el cuerpo cinemático dentro de él se mueve alrededor del mundo. La cámara está dentro de la escena, pero fuera del cuerpo, simplemente siguiéndola.
Para crear la araña, agregué un nodo separado dentro del cuerpo, que contiene puntos falsos para la ubicación de las patas (donde están colocadas en el suelo, no donde están unidas al cuerpo).
Por conveniencia, coloqué las propias patas aquí, en esta escena, pero fuera del cuerpo. El guión que controla cada uno de ellos, además de mover la pata, lo desplegará constantemente hacia el centro de la "araña".
Código dentro del editor Godot
Escribiendo el código. Uso GDScript, porque no veo mucho sentido en escribir en C # en Godot (no soy tan fanático de las llaves):
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)
Escena de masa de araña Godot. Como beneficio adicional, también incluyó momentos de un juego separado con terraformación del mundo voxel, donde también se usa una "araña", pero puramente animada, así como una demostración con autos en playcanvas, antes de que se agregara la forma de araña allí.
Unigine
Una vez que la implementación de Godot estuvo lista, decidí portar esta solución al motor Unigine. Allí también tuve un proyecto con autos , aunque para no sobrecargarlo, hice una horquilla "araña" separada, para que luego, probablemente, le quitara por completo las ruedas y la desarrollara de alguna manera por separado.
Está toda la escena del mundo del juego en la que se encuentra el cuerpo del coche del jugador. Al comienzo del juego, las ruedas ubicadas por separado se acoplan a este cuerpo.
Estoy buscando un maniquí dentro del cuerpo, dentro del cual habrá puntos que marcarán las posiciones de las patas.
Las patas simplemente se colocan en el mundo del juego. El movimiento en sí se deja realizado a través de las ruedas, pero su representación visual está deshabilitada.
Unigine lanza un entorno externo para la edición de código
Código:
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;
}
}
Escena de corte de masa de araña Unigine
PlayCanvas
PlayCanvas es un motor de juegos webGL que utiliza javascript. Recientemente comencé a entenderlo. Parece un cruce entre Unity y Godot, pero con desarrollo en línea: el editor se abre en el navegador.
En este caso, rehice uno de los ejemplos que ofrece esta plataforma, agregando un par de mis modelos de auto, una pequeña funcionalidad adicional como saltar, agregar una cámara y jugar con los materiales / configuraciones.
La representación visual del automóvil base en el ejemplo original fue dada por un modelo sólido, que desactivé parcialmente, dejando solo las ruedas, que son tiradas desde el interior del modelo por su guión de control (es decir, no están enrolladas por nodos separados en la jerarquía de escena). Esta imagen se adhiere a un modelo de rueda física en movimiento durante el juego.
Para implementar la "araña" dentro de este proyecto, creé un "centro de araña" dentro de la representación visual del automóvil. Por conveniencia, el "cuerpo de araña" está anidado dentro de él, ya que quería cambiar inmediatamente a la "forma de araña" y viceversa.
Por lo tanto, la "araña" local también se coloca en la parte superior de la tracción de las ruedas, y las propias ruedas están ocultas. Quizás sería más correcto adjuntar el marco de araña al nodo de física, pero el cambio entre formularios ya está ubicado en el script del nodo con la imagen del automóvil, y otros modelos están dentro de este nodo, así que elegí esta opción por simplicidad. De hecho, resulta que lo visual en su guión se mueve detrás de la física, y los guiones de las patas ya están mirando el marco de la araña moviéndose junto con lo visual. En teoría, puede haber algo de desincronización aquí, al menos noté que en dispositivos débiles algunas patas no tienen tiempo para calcular posiciones y solo algunas se mueven.
Y así, en general, la solución, por supuesto, no está ligada a la física o al cuerpo rígido, a las piernas, de hecho, no les importa cómo muevas el objeto principal, por fuerzas o simplemente cambiando la posición.
Las patas están ubicadas en la escena en sí, pero para la conveniencia de habilitarlas / deshabilitarlas, se recopilan dentro de un nodo separado, de modo que puede simplemente deshabilitarlas, y no cada una mediante un enlace separado.
En playcanvas, el editor de código se inicia en una nueva pestaña del navegador
Código:
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());
}
};
En general, hasta ahora hemos obtenido una araña en blanco con cuatro patas y cálculos no del todo óptimos.
Puede probar el marco resultante
aquí .
Personalmente intenté ejecutar en un teléfono inteligente no demasiado potente a través de Chrome y Dolphin, los gráficos se vuelven similares a PsOne y los cálculos para algunas patas no funcionan, mientras que el nivel es visible en la pantalla, las patas aparecen en el borde del mapa. En una computadora portátil débil, había frenos muy fuertes en Chrome, pero todo salió bien en Firefox. En una computadora portátil con una tarjeta de video discreta y en una estacionaria, vuela en ambos navegadores.
En una PC, a diferencia de los teléfonos inteligentes, esta demostración ejecuta un salto (presionando la barra espaciadora), preparando una ametralladora (Q y E) y recargando un nivel (en R).
Salir
Como puede ver, los lenguajes y los motores son diferentes, pero sin embargo, muchas cosas en la familia de lenguajes de scripting se hacen de una manera bastante similar. ¿Con qué frecuencia dominaste nuevos motores y marcos de juego? ¿Cuáles fueron las principales dificultades a las que te enfrentaste?