entity compass
{
    type = <compass.tga>;
    layer = 10;
    scale_x = 0.25;
    scale_y = 0.25;
    x = 190;
    y = -85;
    z = -65;
    view = camera;
    flags = overlay, visible;
}
    


entity needle
{
    type = <needle.tga>;
    layer = 20;
    scale_x = 0.15;
    scale_y = 0.15;
    x = 190;
    y = -85;
    z = -65;
    view  = camera;
    flags = overlay, nofilter, visible;
}

Diese “entity”-Definitionen greifen auf zwei TGA-Dateien zurück; wie Sie sehen, stelle ich Ihre Größe und Position in der 3D-Welt ein (x ist der Abstand zur Kamera, y ist die x-Position auf dem Bildschirm und z ist die y-Position auf dem Bildschirm). Die Kompassnadel erhält einen Layer von 20, also wird sie über dem Kompass mit layer 10 erscheinen. Und schließlich: die Nadel hat den “nofilter”-Flag gesetzt, wodurch sie schärfer gerendert wird, ohne das etwas verschwommene Aussehen.

starter set_compass()
{
  while (player == null) {wait (1);} // wait until the player is loaded in the level
  while (1)
  { 
      needle.roll = -player.pan;
      wait (1);
  }
}

Die Starter Funktion wartet bis der Spieler entstanden ist und stellt dann den Roll der Nadel je nach dem negativen Pan des Spielers ein.

 

Fliegende Vögel

Ich erinnere mich noch gut daran wie ich zum ersten Mal Unreal 1 gespielt habe. Ich wurde gefangengenommen, bin entkommen und habe die Höhle verlassen. Ich war beeindruckt! Die riesigen Außenbereiche mit Bäumen, Wasserflächen und die Vögel, die hoch über mir kreisten... das waren noch Zeiten! Der Ausschnitt unten beinhaltet Code für einen Vogel, der fliegt und sich um sich selbst kümmert. Sehen wir ihn uns für eine Sekunde an:

action move_bird
{
    var init_pos; // initial position of the bird
    var bird_speed; // flying speed
    var flying_distance;
    flying_distance = my.skill1;
    if (flying_distance == 0) {flying_distance = 2000;} // default flying distance
    bird_speed = my.skill2;
    if (bird_speed == 0) {bird_speed = 5;} // default flying speed
    my.passable = on;
    vec_set (init_pos.x, my.x); // store the initial position of the bird
    while (1)
    {
       temp.x = bird_speed * time;
       temp.y = 0;
       temp.z = 0;
       move_mode = ignore_passable;
       my.skill40 += ent_move (temp, nullvector); // move in the direction given by the pan angle in Wed
       if (my.skill40 > flying_distance)
       {
            my.skill40 = 0;
            vec_set (my.x, init_pos.x);
       }
       ent_cycle("walk", my.skill1); // animate the bird
       my.skill1 += 3 * time; // animation speed
       my.skill1 %= 100; // loop animation
       wait (1);
    }
}

Wir haben einige Variablen definiert; init_pos stellt die Startposition des Vogels ein, bird_speed gibt seine Geschwindigkeit an und flying_distance ist die Strecke, die der Vogel zurücklegt, ehe er zu seiner Anfangsposition zurückkehrt. Sie können flying_distance und bird_speed einstellen, indem Sie skill1 und skill2 im WED setzen, aber falls Sie das vergessen, nimmt der Code die Defaultwerte von 2000 bzw. 5. Wir machen den Vogel passable (optional) und speichern seine Anfangsposition (wo er im WED plaziert wurde) in init_pos, bevor wir in die Schleife eintreten. Die Geschwindigkeit des Vogels wird an die Framerate angepaßt und die zurückgelegte Distanz wird in skill40 aufaddiert; falls dieser Wert flying_distance übersteigt, wird der Vogel auf seine Startposition zurückgesetzt und der Prozess beginnt erneut. Die letzten Zeilen animieren das Model; meines hat einen seltsamen Animationsnamen (walk), aber Sie können hier den Namen der Animation Ihres Models eintragen.

Wie verwendet man die Vögel? Plazieren Sie sie in etwas verschiedenen Höhen in Ihrem Level, wählen Sie Ausrichtung und eine geeignete Geschwindigkeit. Die Flugdistanz sollte groß genug sein, damit der Spieler nicht merkt, dass er immer den gleichen Vogel sieht; stellen Sie sicher, dass der Vogel in Bereichen startet und ankommt, die nicht eingesehen werden können. Viel Spaß!