Minikarte

3DGS erlaubt es, mehrere Views gleichzeitig auf dem Bildschirm zu haben. Ich habe dieses großartige Feature genutzt, um eine Vogelperspektive des Levels auf den Bildschirm zu bringen.

Sehen wir uns zunächst die Definition der View an:

view top_view
{
layer = 15;
pos_x = 0;
pos_y = 0;
size_x = 200;
size_y = 150;
tilt = -90;
arc = 80;
}

Ihre Größe ist 200 x 150 Pixel und sie erscheint in der oberen linken Ecke des Bildschirms. Sie schaut nach unten, weil ihr tilt Wert auf –90 gesetzt ist und der Zoomfaktor steht auf 80 (ändern Sie diesen Wert, wenn Sie mehr oder weniger Ihres Levels in dem Fenster sehen wollen).

Mit Hilfe einer “starter” Funktion (das ist eine, die von selbst läuft, wenn das Level gestartet wird) wird die Karte angezeigt bzw. verborgen:

starter init_topcam()
{
while (player == null) {wait (1);}
while (1)
{
if (key_t == 1)
{
while (key_t == 1) {wait (1);}
if (top_view.visible == on)
{
top_view.visible = off;
}
else
{
top_view.visible = on;
}
}
top_view.x = player.x;
top_view.y = player.y;
top_view.z = 1000; // play with this value
wait (1);
}
}

Wir warten bis der Spieler im Level ist, dann zeigen bzw. verbergen wir die Karte, wenn die “T” Taste gedrückt wird. Die x und y Koordinaten werden vom Spieler übernommen und die Höhe auf 1000 Quants gesetzt. Ihre Levels könnten andere Höhen haben, also ändern Sie den Wert enstprechend.

Sie sollten Ihrer Karte auch einen kleinen Rahmen geben (z.B. mit 2 oder 4 dünnen Panels).

Wassertropfen

Dieser Effekt könnte Ihr Spiel ziemlich aufwerten. Ich würde Ihn in Höhlen benutzen, für tropfende Rohre und (warum nicht?) für Regen!

Mein Beispiel zeigt die Tropfen, wie sie aus einem Rohr fallen und im Pool Wellen erzeugen. Dazu muß ein Tropfengenerator im Level plaziert werden und dies ist die Action, die dazu gehört:

action drop_generator
{
my.invisible = on;
my.passable = on;
while (1)
{
ent_create(drop_mdl, my.pos, falling_drop);
sleep (4 + random(2));
}
}

Der Generator selbst ist unsichtbar und passierbar, also ist es egal, welches Model verwendet wird, ich habe das Model des Tropfens selbst benutzt. Alle 4 bis 6 Sekunden wird ein Tropfen an der Position des Generators erzeugt. Dieser startet die Funktion mit Namen falling_drop:

function falling_drop()
{
my.flare = on;
vec_set(temp, my.pos);
vec_set(drop_height, my.pos);
temp.z -= 5000; // trace 5000 quants below the drop generator
trace_mode = ignore_me + ignore_models + ignore_sprites;
drop_height.z = my.z - trace(my.x, temp) + 2; // place the ripple sprite 2 quants above the water surface
while (my.z > drop_height.z)
{
my.z -= 3 * time;
wait (1);
}
ent_create(ripple_pcx, my.pos, ripple_effect);
ent_remove(me); // remove the drop
}

Der Tropfen hat das Flare Flag gesetzt. Wir führen einen trace zwischen der aktuellen Position und einer weiteren 5000 Quants tiefer aus und speichern das Ergebnis (die Höhe des Tropfens über der Oberfläche) in drop_height.z. Zu dem Wert addieren wir noch 2 Quants, weil wir das Sprite für den Welleneffekt leicht oberhalb der Wasseroberfläche haben wollen.

Der Tropfen fällt, weil wir seine z Koordinate in einer While Schleife ändern und sobald die Höhe der Wasseroberfläche erreicht wurde, erstellen wir den Welleneffekt (ein Sprite namens ripple_pcx) und entfernen den Tropfen:

function ripple_effect()
{
ent_playsound (my, drip_wav, 500);
my.oriented = on;
my.flare = on;
my.alpha = 60;
my.tilt = 90;
while (my.scale_x < 5)
{
my.scale_x += 0.03 * time;
my.scale_y = my.scale_x;
if (my.scale_x > 3)
{
my.alpha -= 1 * time;
}
wait (1);
}
ent_remove(me); // remove the sprite
}

Der drip_wav Sound ertönt, wir setzen die Flags “oriented” und “flare” für das Sprite und suchen uns geeignete “tilt” und “alpha” Werte aus. In einer Schleife vergrößern wir das Sprite und verringern den Alpha, wenn die Skalierung über 3 wächst. Ist die Aklierung größer als 5, wird das Sprite entfernt.