Dieses Mal soll gezeigt werden, wie Sie sechs verschiedene Kameraarten programmieren können, die allen derartigen Bedarf für die meisten Spiele decken sollten. Schauen wir uns direkt den Code an:
Beachten Sie zunächst die seltsam aussehenden Deklarationen:
function fixed_camera(); // function prototypes
function first_person_camera();
function top_camera();
function side_camera();
function isometric_camera();
function follow_camera();
Diese sind, wie Sie vermutlich schon erraten haben, Prototypen. Wenn Funktionen auf diese Art deklariert werden, weiß die Engine von ihrer Existenz und wird keine Fehlermeldung erzeugen, wenn sie aufgerufen werden, bevor sie definiert werden. Klingt kompliziert? Sehen wir uns ein praktisches Beispiel aus dem Skript an:
function main()
{
level_load (work28_wmb);
wait (3); // wait until the level is loaded
// call the desired camera function here
fixed_camera();
}
function fixed_camera() // doesn't move and doesn't change its angles
{
vec_set (camera.x, vector (700, 600, 500)); // camera position on the x, y, z axis; use your own values
camera.pan = 225; // pan angle, use your own value here
camera.tilt = -45; // tilt angle, use your own value here
camera.arc = 80; // zoom factor, put your own value here
}
Die main Funktion möchte die Funktion fixed_camera() aufrufen, die aber erst einige Zeilen tiefer deklariert wird. Die Engine liest den Code wie ein Mensch, von oben nach unten, also kennt die Funktion main() die Funktion fixed_camera() noch nicht, weil diese erst darunter definiert wird und die Engine so weit noch nicht gelesen hat. Was ist die Lösung? Wir können entweder fixed_cmaera() vor der main Funktion deklarieren oder Prototypen verwenden, die einfach aus dem Schlüsselwort “function”, dem Funktionsnamen mit Klammern und einem Semikolon bestehen. Diese Prototypen sollten natürlich am Anfang des Skriptes definiert sein, bevor sie benutzt werden.
Zurück zu unserer main Funktion: diese lädt ein Level und ruft dann eine unserer sechs Kamerafunktionen auf. Ersetzen Sie “fixed_camera()” durch “first_person_camera()” usw., wenn Sie diesen Workshop durcharbeiten.
Die Funktion fixed_camera() enthält wie der Name schon sagt Code für eine feste Kamera. Sie können den Spieler mit Hilfe der Tasten WASD bewegen, aber die Kamera behält ihre Position und Ausrichtung bei. Diese Kamera ist nützlich, wenn Ihr Spiel in einem kleinen Bereich stattfindet oder wenn nicht so viel Aktivität auf dem Bildschirm ist (Schachspiele, Schiffe versenken, etc.). Der Code dafür ist wirklich leicht:
function fixed_camera() // doesn't move and doesn't change its angles
{
vec_set (camera.x, vector (700, 600, 500)); // camera position on the x, y, z axis; use your own values
camera.pan = 225; // pan angle, use your own value here
camera.tilt = -45; // tilt angle, use your own value here
camera.arc = 80; // zoom factor, put your own value here
}
Die ersten Codezeilen legen die Position der Kamera auf x = 700, y = 600 und z = 500 fest. Die folgenden Zeilen setzen die Winkel und den Zoom Faktor. Ändern Sie diese Werte entsprechend ab, ich habe alle (bis auf camera.arc) aus dem WED abgelesen. Sie können viele statische Kameras auf diese Weise erzeugen, indem Sie einfach die Werte manipulieren. Hier ist ein “Fischaugenblick”:
Weiter zur nächsten Kameraart; vergessen Sie nicht, in der main Funktion “fixed_camera();” durch “first_person_camera();” zu ersetzen (dies ist der letzte Hinweis!).
function first_person_camera() // follows the player at all times
{
while (player == null) {wait (1);} // wait until the player is created
player.invisible = on; // no need to see the player in 1st person mode
while (1)
{
camera.x = player.x; // keep the camera at the player's position
camera.y = player.y;
camera.z = player.z + 35; // compute the approximate height of the eye; play with 35
camera.pan = player.pan; // the angles of the camera are identical to player's angles
camera.tilt = player.tilt;
wait (1);
}
}
Diese Kamera kommt hauptsächlich in Shooter und Abenteuerspielen zum Einsatz. Die Funktion first_person_camera() macht das Spielermodel unsichtbar und hält dann die Kamera an der gleichen Position wie das Spielermodel, zumindest in x und y Richtung. In z Richtung wird die Kamera 35 Quants über dem Origin des Spielers plaziert, diesen Wert habe ich dem MED entnommen:
Die letzten Zeilen stellen sicher, dass die Ausrichtung der Kamera der des Spielers entspricht, was für Spiele in der Egoperspektive eine wichtige Rolle spielt. Ich werde Ihnen einen Screenshot mit dieser Kameraart zeigen, aber ich bin sicher, dass Sie diese Art schon kennen.
Auf zur nächsten Kamera: die Top Ansicht, auch Vogelperspektive genannt.
function top_camera() // displays a top view of the player and the surrounding level parts
{
while (player == null) {wait (1);} // wait until the player is created
camera.tilt = -90; // the camera will look downwards all the time
while (1)
{
camera.x = player.x; //the player and the camera have the same x and y position
camera.y = player.y;
camera.z = player.z + 300; // but the camera is placed 300 quants higher; play with this value
camera.pan = player.pan; // the camera shares the same pan angle with the player
wait (1);
}
}
Die Funktion setzt den tilt auf –90, wodurch die Kamera nach unten ausgerichtet ist; die Kamera übernimmt Position und pan vom Spieler, aber wird in z Richtung 300 Quants über dem Spieler plaziert. Diese Höhe können Sie beliebig ändern, größere Werte (500, 1000, ...) erlauben eine größere Sicht auf das umliegende Level.
Es wird Zeit, den zweiten Teil des Skriptes zu anlysieren; ich habe den Code für den Spieler ignoriert, der schon im vorigen (27.) Workshop besprochen wurde.
Die Funktion side_camera() eignet sich hervorragend für Spiele mit einer Ansicht von der Seite, wie Plattformspiele, Logikspiele und so weiter.
function side_camera() // shows the player from a side view
{
while (player == null) {wait (1);} // wait until the player is created
while (1)
{
camera.x = player.x + 200 * sin(player.pan); // 200 = distance between the player and the camera
camera.y = player.y - 200 * cos(player.pan) ; // use the same value here
camera.z = player.z + 40; // place the camera a little higher than player's origin, play with this value
camera.pan = player.pan + 90; // face the player at all times
wait (1);
}
}
Diese Funktion plaziert die Kamera 200 Quants seitlich und 40 Quants oberhalb vom Origin des Spielers; natürlich können (und sollten!) Sie diese Werte nach Ihren Bedürfnissen abändern. Der Code hält die Kamera auf einem Kreis mit 200 Quants Radius, in dessen Zentrum der Spieler steht; die Kamera ist dabei immer auf den Spieler ausgerichtet, weil ihr pan Winkel gleich dem des Spielers + 90 ist. Sehen Sie sich das Bild an, um besser zu verstehen, wie alles funktioniert.
Eine gute Idee für einen Sidescroller wäre es, die Bewegung des Spielers auf eine einzelne Achse zu begrenzen; Sie können zum Beispiel diese Zeile in der Action players_code auskommentieren:
my.pan += 6 * (key_a - key_d) * time; // rotate the player using the "A" and "D" keys
Und selbst sehen, was geschieht; diese Kamera ist gut für Kampfspiele, Plattformspiele und so weiter. Vergessen Sie nicht, dass der Wert für den Abstand zum Spieler zweimal im Code vorkommt (für sin und cos), Sie müssen diesen also gegebenenfalls an zwei Stellen abändern.
Was kommt als nächstes? Die Funktion isometric_camera() liefert eine Kamera, wie sie von vielen Spielen verwendet wird.
Ihre Rolle ist es, den Spieler (oder einen Teil von ihm) zu zeigen und ihm in einer Außenansicht zu folgen.
function isometric_camera() // displays the player from an isometric view aka 3rd person view
{
while (player == null) {wait (1);} // wait until the player is created
camera.tilt = -15; // look down at the player, play with this value
while (1)
{
camera.x = player.x - 250 * cos(player.pan); // 250 = distance between the player and the camera
camera.y = player.y - 250 * sin(player.pan); // use the same value here
camera.z = player.z + 150; // place the camera above the player, play with this value
camera.pan = player.pan; // the camera and the player have the same pan angle
wait (1);
}
}
Der Tilt der Kamera ist stets –15, wodurch die Kamera auf den Spieler herunterschaut. Ändern Sie diesen Wert ebenso wie die 250 und die 150 bsi Sie den gewünschten Effekt erzielen. Diese Kamera befindet sich auch auf einem Kreis um den Spieler, allerdings haben Kamera und Spieler den gleichen Pan Winkel. Sie können die Werte ändern, um andere Arten von dieser Kamera zu erhalten; vergessen Sie nicht, die 250 zweimal abzuändern.
Hier sind noch einige Beispiele, die diese Kamera zeigen.
Schauen wir uns die letzte Kamera im Workshop an; ich habe sie follow_camera genannt, weil sie den Spieler immer im Blick behält.
function follow_camera() // this fixed camera changes its angles, focusing on the player
{
while (player == null) {wait (1);} // wait until the player is created
camera.arc = 60; // zoom factor, play with this value
vec_set (camera.x, vector(700, 600, 350)); // set the position of the camera; put your own values here
while (1)
{
vec_set(temp.x, player.x);
vec_sub(temp.x, camera.x);
vec_to_angle(camera.pan, temp); // rotate the camera toward the player every frame
wait (1);
}
}
Sie kennen diese Kamera bereits aus dem vorigen Workshop, wo auch genau erklärt wird, wie sie funktioniert. Uns interessiert hier der Zoom Faktor (60 im Beispiel) und ihre Position, die auf x = 700, y = 600 und z = 350 gesetzt ist. Die Werte habe ich wieder dem WED entnommen, ersetzen Sie diese gegebenenfalls durch passendere Werte für Ihre Anwendung.
Die Kamera behält den Spieler die ganze Zeit im Blick und ist für eine ganze Reihe von Spielen nützlich.
Schwer zu glauben, aber hier endet der Workshop. Ich habe mich bemüht, die Grundtypen von Kameras hier vorzustellen, aber Sie können komplexere Beispiele finden, wenn Sie das AUM lesen (sehen Sie sich zum Beispiel die Morrowing Kamera an), ebenso wie die Templates oder andere Beispiele aus dem Forum von Conitec.
Der folgende Workshop handelt von Events, die sehr wichtig für jedes Spiel sind, bei dem sich Dinge (Models, Sprites, etc.) in Bewegung befinden. Bis bald!